Fix use of generic function type aliases for fields (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 8448 matching lines @@
 
   /**
    * 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) {
-            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]);
-              }
-            }
+      if (annotation is TypeName && element is GenericTypeAliasElementImpl) {
+        TypeArgumentList argumentList = annotation.typeArguments;
+        List<DartType> typeArguments = null;
+        if (argumentList != null) {
+          List<TypeAnnotation> arguments = argumentList.arguments;
+          int argumentCount = arguments.length;
+          typeArguments = new List<DartType>(argumentCount);
+          for (int i = 0; i < argumentCount; i++) {
+            typeArguments[i] = _getType(arguments[i]);
           }
-          typeArguments ??=
-              new List<DartType>.filled(parameterCount, dynamicType);
-          functionType =
-              functionType.substitute2(typeArguments, parameterTypes);
         }
-        return functionType;
+        return element.typeAfterSubstitution(typeArguments);
       }
     }
     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 2423 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }