Support for generic function as type arguments in DeclarationResolver.

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 261 matching lines @@
       });
       _resolveMetadata(node, node.metadata, element);
       return null;
     } else {
       return super.visitFunctionTypedFormalParameter(node);
     }
   }
 
   @override
   Object visitGenericFunctionType(GenericFunctionType node) {
-    GenericFunctionTypeElement element = node.type.element;
-    _setGenericFunctionType(node.returnType, element.returnType);
-    _walk(new ElementWalker.forGenericFunctionType(element), () {
-      super.visitGenericFunctionType(node);
-    });
+    if (_walker.elementBuilder != null) {
+      _walker.elementBuilder.visitGenericFunctionType(node);
+    } else {
+      DartType type = node.type;
+      if (type != null) {
+        Element element = type.element;
+        if (element is GenericFunctionTypeElement) {
+          _setGenericFunctionType(node.returnType, element.returnType);
+          _walk(new ElementWalker.forGenericFunctionType(element), () {
+            super.visitGenericFunctionType(node);
+          });
+        }
+      }
+    }
     return null;
   }
 
   @override
   Object visitGenericTypeAlias(GenericTypeAlias node) {
     GenericTypeAliasElementImpl element =
         _match(node.name, _walker.getTypedef());
     _setGenericFunctionType(node.functionType, element.function?.type);
     _walk(new ElementWalker.forGenericTypeAlias(element), () {
       super.visitGenericTypeAlias(node);
@@ skipping 242 matching lines @@
       _resolveAnnotations(parent, nodes, element.metadata);
     }
   }
 
   /**
    * If the given [typeNode] is a [GenericFunctionType], set its [type].
    */
   void _setGenericFunctionType(TypeAnnotation typeNode, DartType type) {
     if (typeNode is GenericFunctionTypeImpl) {
       typeNode.type = type;
+    } else if (typeNode is NamedType) {
+      typeNode.type = type;
+      if (type is ParameterizedType) {
+        List<TypeAnnotation> nodes =
+            typeNode.typeArguments?.arguments ?? const [];
+        List<DartType> types = type.typeArguments;
+        if (nodes.length == types.length) {
+          for (int i = 0; i < nodes.length; i++) {
+            _setGenericFunctionType(nodes[i], types[i]);
+          }
+        }
+      }
     }
   }
 
   /**
    * Recurses through the element model and AST, verifying that all elements are
    * matched.
    *
    * Executes [callback] with [_walker] pointing to the given [walker] (which
    * should be a new instance of [ElementWalker]).  Once [callback] returns,
    * uses [ElementWalker.validate] to verify that all expected elements have
@@ skipping 235 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);
 }