Support for using generic function types in other AST structures.

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';
+import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/exception/exception.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/element/builder.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 
 /**
  * A visitor that resolves declarations in an AST structure to already built
  * elements.
@@ skipping 197 matching lines @@
       if (_walker.element is ExecutableElement) {
         element = _match(functionName, _walker.getFunction());
       } else if (property.keyword == Keyword.GET) {
         element = _match(functionName, _walker.getAccessor());
       } else {
         assert(property.keyword == Keyword.SET);
         element = _match(functionName, _walker.getAccessor(),
             elementName: functionName.name + '=');
       }
     }
+    _setGenericFunctionType(node.returnType, element.returnType);
     node.functionExpression.element = element;
     _walker._elementHolder?.addFunction(element);
     _walk(new ElementWalker.forExecutable(element, _enclosingUnit), () {
       super.visitFunctionDeclaration(node);
     });
     _resolveMetadata(node, node.metadata, element);
     return null;
   }
 
   @override
@@ skipping 33 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);
     });
     return null;
   }
 
   @override
   Object visitGenericTypeAlias(GenericTypeAlias node) {
     GenericTypeAliasElementImpl element =
         _match(node.name, _walker.getTypedef());
-    (node.functionType as GenericFunctionTypeImpl)?.type =
-        element.function?.type;
+    _setGenericFunctionType(node.functionType, 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);
@@ skipping 47 matching lines @@
           _match(methodName, _walker.getFunction(), elementName: elementName);
     } else {
       if (property.keyword == Keyword.GET) {
         element = _match(methodName, _walker.getAccessor());
       } else {
         assert(property.keyword == Keyword.SET);
         element = _match(methodName, _walker.getAccessor(),
             elementName: nameOfMethod + '=');
       }
     }
+    _setGenericFunctionType(node.returnType, element.returnType);
     _walk(new ElementWalker.forExecutable(element, _enclosingUnit), () {
       super.visitMethodDeclaration(node);
     });
     _resolveMetadata(node, node.metadata, element);
     return null;
   }
 
   @override
   Object visitPartDirective(PartDirective node) {
     super.visitPartDirective(node);
@@ skipping 16 matching lines @@
     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 = element;
-      TypeAnnotation type = node.type;
-      if (type is GenericFunctionTypeImpl) {
-        type.type = element.type;
-      }
+      _setGenericFunctionType(node.type, element.type);
       _walk(new ElementWalker.forParameter(element), () {
         super.visitSimpleFormalParameter(node);
       });
       _resolveMetadata(node, node.metadata, element);
       return null;
     } else {
       return super.visitSimpleFormalParameter(node);
     }
   }
 
@@ skipping 46 matching lines @@
     } else {
       return super.visitVariableDeclaration(node);
     }
   }
 
   @override
   Object visitVariableDeclarationList(VariableDeclarationList node) {
     if (_walker.elementBuilder != null) {
       return _walker.elementBuilder.visitVariableDeclarationList(node);
     } else {
-      super.visitVariableDeclarationList(node);
+      node.variables.accept(this);
+      VariableElement firstVariable = node.variables[0].element;
+      _setGenericFunctionType(node.type, firstVariable.type);
+      node.type?.accept(this);
       if (node.parent is! FieldDeclaration &&
           node.parent is! TopLevelVariableDeclaration) {
-        _resolveMetadata(node, node.metadata, node.variables[0].element);
+        _resolveMetadata(node, node.metadata, firstVariable);
       }
       return null;
     }
   }
 
   /**
    * Updates [identifier] to point to [element], after ensuring that the
    * element has the expected name.
    *
    * If no [elementName] is given, it defaults to the name of the [identifier]
@@ skipping 51 matching lines @@
    * built.
    */
   void _resolveMetadata(
       AstNode parent, NodeList<Annotation> nodes, Element element) {
     if (element != null) {
       _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;
+    }
+  }
+
+  /**
    * 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
    * been matched.
    */
   void _walk(ElementWalker walker, void callback()) {
     ElementWalker outerWalker = _walker;
@@ skipping 231 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);
 }