Fixes incorrect generic function type capture

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 engine.resolver;
 
 import 'dart:collection';
 
 import '../task/strong/info.dart' show InferredType, StaticInfo;
 import '../task/strong/rules.dart' show TypeRules;
@@ skipping 14941 matching lines @@
         }
       }
       _setElement(typeName, _dynamicType.element);
       typeName.staticType = _dynamicType;
       node.type = _dynamicType;
       return null;
     }
     if (argumentList != null) {
       NodeList<TypeName> arguments = argumentList.arguments;
       int argumentCount = arguments.length;
-      List<DartType> parameters = _getTypeArguments(type);
+      List<DartType> parameters = _getTypeParameters(type);
       int parameterCount = parameters.length;
       List<DartType> typeArguments = new List<DartType>(parameterCount);
       if (argumentCount == parameterCount) {
         for (int i = 0; i < parameterCount; i++) {
           TypeName argumentTypeName = arguments[i];
           DartType argumentType = _getType(argumentTypeName);
           if (argumentType == null) {
             argumentType = _dynamicType;
           }
           typeArguments[i] = argumentType;
         }
       } else {
         reportErrorForNode(_getInvalidTypeParametersErrorCode(node), node,
             [typeName.name, parameterCount, argumentCount]);
         for (int i = 0; i < parameterCount; i++) {
           typeArguments[i] = _dynamicType;
         }
       }
-      if (type is InterfaceTypeImpl) {
-        InterfaceTypeImpl interfaceType = type as InterfaceTypeImpl;
-        type = interfaceType.substitute4(typeArguments);
-      } else if (type is FunctionTypeImpl) {
-        FunctionTypeImpl functionType = type as FunctionTypeImpl;
-        type = functionType.substitute3(typeArguments);
-      } else {
-        // TODO(brianwilkerson) Report this internal error.
-      }
+      type = _instantiateType(type, typeArguments);
     } else {
       //
       // Check for the case where there are no type arguments given for a
       // parameterized type.
       //
-      List<DartType> parameters = _getTypeArguments(type);
+      List<DartType> parameters = _getTypeParameters(type);
       int parameterCount = parameters.length;
       if (parameterCount > 0) {
         DynamicTypeImpl dynamicType = DynamicTypeImpl.instance;
         List<DartType> arguments = new List<DartType>(parameterCount);
         for (int i = 0; i < parameterCount; i++) {
           arguments[i] = dynamicType;
         }
-        type = type.substitute2(arguments, parameters);
+        type = _instantiateType(type, arguments);
       }
     }
     typeName.staticType = type;
     node.type = type;
     return null;
   }
 
   @override
   Object visitTypeParameter(TypeParameter node) {
     super.visitTypeParameter(node);
@@ skipping 164 matching lines @@
     }
     return type;
   }
 
   /**
    * Return the type arguments associated with the given type.
    *
    * @param type the type whole type arguments are to be returned
    * @return the type arguments associated with the given type
    */
-  List<DartType> _getTypeArguments(DartType type) {
+  List<DartType> _getTypeParameters(DartType type) {
     if (type is InterfaceType) {
       return type.typeArguments;
     } else if (type is FunctionType) {
-      return type.typeArguments;
+      return TypeParameterTypeImpl.getTypes(type.boundTypeParameters);
     }
     return DartType.EMPTY_LIST;
   }
 
   /**
    * 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 18 matching lines @@
       if (element is ClassElement) {
         if (type != null) {
           return null;
         }
         type = element.type;
       }
     }
     return type;
   }
 
+  DartType _instantiateType(DartType type, List<DartType> typeArguments) {
+    if (type is InterfaceTypeImpl) {
+      return type.substitute4(typeArguments);
+    } else if (type is FunctionTypeImpl) {
+      return type.instantiate(typeArguments);
+    } else {
+      // TODO(brianwilkerson) Report this internal error.
+      return type;
+    }
+  }
+
   /**
    * Checks if the given type name is used as the type in an as expression.
    *
    * @param typeName the type name to analyzer
    * @return `true` if the given type name is used as the type in an as expression
    */
   bool _isTypeNameInAsExpression(TypeName typeName) {
     AstNode parent = typeName.parent;
     if (parent is AsExpression) {
       AsExpression asExpression = parent;
@@ skipping 828 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }