More generic function type cases working

pkg/analyzer/lib/src/generated/declaration_resolver.dart

 // Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer.src.generated.declaration_resolver;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 109 matching lines @@
     _walker.elementBuilder.visitDeclaredIdentifier(node);
     return null;
   }
 
   @override
   Object visitDefaultFormalParameter(DefaultFormalParameter node) {
     NormalFormalParameter normalParameter = node.parameter;
     ParameterElement element =
         _match(normalParameter.identifier, _walker.getParameter());
     if (normalParameter is SimpleFormalParameterImpl) {
-      normalParameter.element = node.identifier.staticElement;
+      normalParameter.element = element;
     }
     Expression defaultValue = node.defaultValue;
     if (defaultValue != null) {
       _walk(
           new ElementWalker.forExecutable(element.initializer, _enclosingUnit),
           () {
         defaultValue.accept(this);
       });
     }
     _walk(new ElementWalker.forParameter(element), () {
@@ skipping 128 matching lines @@
         super.visitFunctionTypedFormalParameter(node);
       });
       _resolveMetadata(node, node.metadata, element);
       return null;
     } else {
       return super.visitFunctionTypedFormalParameter(node);
     }
   }
 
   @override
+  Object visitGenericFunctionType(GenericFunctionType node) {
+    GenericFunctionTypeElement element = node.type.element;
+    _walk(new ElementWalker.forGenericFunctionType(element), () {
+      super.visitGenericFunctionType(node);
+    });
+    return null;
+  }
+
+  @override
+  Object visitGenericTypeAlias(GenericTypeAlias node) {
+    GenericTypeAliasElementImpl element =
+        _match(node.name, _walker.getTypedef());
+    (node.functionType as GenericFunctionTypeImpl)?.type =
+        element.function?.type;
+    _walk(new ElementWalker.forGenericTypeAlias(element), () {
+      super.visitGenericTypeAlias(node);
+    });
+    _resolveMetadata(node, node.metadata, element);
+    return null;
+  }
+
+  @override
   Object visitImportDirective(ImportDirective node) {
     super.visitImportDirective(node);
     List<ElementAnnotation> annotations =
         _enclosingUnit.getAnnotations(node.offset);
     if (annotations.isEmpty && node.metadata.isNotEmpty) {
       int index = (node.parent as CompilationUnit)
           .directives
           .where((directive) => directive is ImportDirective)
           .toList()
           .indexOf(node);
@@ skipping 74 matching lines @@
   Object visitPartOfDirective(PartOfDirective node) {
     node.element = _enclosingUnit.library;
     return super.visitPartOfDirective(node);
   }
 
   @override
   Object visitSimpleFormalParameter(SimpleFormalParameter node) {
     if (node.parent is! DefaultFormalParameter) {
       ParameterElement element =
           _match(node.identifier, _walker.getParameter());
-      (node as SimpleFormalParameterImpl).element =
-          node.identifier.staticElement;
+      (node as SimpleFormalParameterImpl).element = element;
+      TypeAnnotation type = node.type;
+      if (type is GenericFunctionTypeImpl) {
+        type.type = element.type;
+      }
       _walk(new ElementWalker.forParameter(element), () {
         super.visitSimpleFormalParameter(node);
       });
       _resolveMetadata(node, node.metadata, element);
       return null;
     } else {
       return super.visitSimpleFormalParameter(node);
     }
   }
 
@@ skipping 69 matching lines @@
    * If no [elementName] is given, it defaults to the name of the [identifier]
    * (or the empty string if [identifier] is `null`).
    *
    * If [identifier] is `null`, nothing is updated, but the element name is
    * still checked.
    */
   Element/*=E*/ _match/*<E extends Element>*/(
       SimpleIdentifier identifier, Element/*=E*/ element,
       {String elementName, int offset}) {
     elementName ??= identifier?.name ?? '';
-    offset ??= identifier.offset;
+    offset ??= identifier?.offset ?? -1;
     if (element.name != elementName) {
       throw new StateError(
           'Expected an element matching `$elementName`, got `${element.name}`');
     }
     identifier?.staticElement = element;
     _matchOffset(element, offset);
     return element;
   }
 
   void _matchOffset(Element element, int offset) {
@@ skipping 135 matching lines @@
 
   /**
    * Creates an [ElementWalker] which walks the child elements of a compilation
    * unit element.
    */
   ElementWalker.forExecutable(
       ExecutableElement element, CompilationUnitElement compilationUnit)
       : this._forExecutable(element, compilationUnit, new ElementHolder());
 
   /**
+   * Creates an [ElementWalker] which walks the child elements of a typedef
+   * element.
+   */
+  ElementWalker.forGenericFunctionType(GenericFunctionTypeElement element)
+      : element = element,
+        _parameters = element.parameters,
+        _typeParameters = element.typeParameters;
+
+  /**
+   * Creates an [ElementWalker] which walks the child elements of a typedef
+   * element defined using a generic function type.
+   */
+  ElementWalker.forGenericTypeAlias(FunctionTypeAliasElement element)
+      : element = element,
+        _typeParameters = element.typeParameters;
+
+  /**
    * Creates an [ElementWalker] which walks the child elements of a parameter
    * element.
    */
   ElementWalker.forParameter(ParameterElement element)
       : element = element,
         _parameters = element.parameters,
         _typeParameters = element.typeParameters;
 
   /**
    * Creates an [ElementWalker] which walks the child elements of a typedef
@@ skipping 110 matching lines @@
 class _ElementMismatchException extends AnalysisException {
   /**
    * Creates an exception to refer to the given [compilationUnit], [element],
    * and [cause].
    */
   _ElementMismatchException(
       CompilationUnitElement compilationUnit, Element element,
       [CaughtException cause = null])
       : super('Element mismatch in $compilationUnit at $element', cause);
 }