Fix generic function types in variable declarations (issue 29237)

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

 // Copyright (c) 2014, 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.resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_resolution_map.dart';
@@ skipping 8443 matching lines @@
     return null;
   }
 
   /**
    * Return the type represented by the given type [annotation].
    */
   DartType _getType(TypeAnnotation annotation) {
     DartType type = annotation.type;
     if (type == null) {
       return undefinedType;
+    } else if (type is FunctionType) {
+      Element element = type.element;
+      if (annotation is TypeName && element is GenericTypeAliasElement) {
+        List<TypeParameterElement> parameterElements = element.typeParameters;
+        FunctionType functionType = element.function.type;
+        if (parameterElements.isNotEmpty) {
+          List<DartType> parameterTypes =
+              TypeParameterTypeImpl.getTypes(parameterElements);
+          int parameterCount = parameterTypes.length;
+          TypeArgumentList argumentList = annotation.typeArguments;
+          List<DartType> typeArguments;
+          if (argumentList == null) {
+            typeArguments =
+                new List<DartType>.filled(parameterCount, dynamicType);
+          } else {
+            List<TypeAnnotation> arguments = argumentList.arguments;
+            int argumentCount = arguments.length;
+            if (argumentCount == parameterCount) {
+              typeArguments = new List<DartType>(parameterCount);
+              for (int i = 0; i < parameterCount; i++) {
+                typeArguments[i] = _getType(arguments[i]) ?? dynamicType;

[scheglov, 2017/04/05 00:11:56]

Is this recursion?
It seems that _getType() does not return null.

[Brian Wilkerson, 2017/04/05 13:23:23]

Yes, but it's guaranteed to terminate because it's based on the lexical
structure, not the element model.
Done. This was copied from another location, which I have also fixed.

+              }
+            } else {
+              typeArguments =
+                  new List<DartType>.filled(parameterCount, dynamicType);

[scheglov, 2017/04/05 00:11:56]

Could be a bit simpler with typeArguments ??= ...filled() after if statements.

[Brian Wilkerson, 2017/04/05 13:23:23]

Done

+            }
+          }
+          functionType =
+              functionType.substitute2(typeArguments, parameterTypes);
+        }
+        return functionType;
+      }
     }
     return type;
   }
 
   /**
    * Returns the simple identifier of the given (may be qualified) type name.
    *
    * @param typeName the (may be qualified) qualified type name
    * @return the simple identifier of the given (may be qualified) type name.
    */
@@ skipping 2422 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }