Allow explicitly passing generic function type args

pkg/analyzer/lib/src/generated/element_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.element_resolver;
 
 import 'dart:collection';
 
 import 'ast.dart';
 import 'element.dart';
@@ skipping 617 matching lines @@
             target, staticType, methodName, isConditional);
         // If we have propagated type information use it (since it should
         // not be redundant with the staticType).  Otherwise, don't produce
         // a propagatedElement which duplicates the staticElement.
         if (propagatedType is InterfaceType) {
           propagatedElement = _resolveInvokedElementWithTarget(
               target, propagatedType, methodName, isConditional);
         }
       }
     }
+    //
+    // Check for a generic method & apply type arguments if any were passed.
+    //
+    if (staticElement is MethodElement || staticElement is FunctionElement) {
+      FunctionType type = (staticElement as ExecutableElement).type;
+      List<TypeParameterElement> parameters = type.boundTypeParameters;
+
+      NodeList<TypeName> arguments = node.typeArguments?.arguments;
+      if (arguments != null && arguments.length != parameters.length) {
+        // Wrong number of type arguments. Ignore them
+        arguments = null;
+        _resolver.reportErrorForNode(
+            StaticTypeWarningCode.WRONG_NUMBER_OF_TYPE_ARGUMENTS,
+            methodName,
+            [type, parameters.length, arguments.length]);
+      }
+      if (parameters.isNotEmpty) {
+        List<DartType> typeArgs;
+        if (arguments == null) {
+          typeArgs = new List<DartType>.filled(
+              parameters.length, DynamicTypeImpl.instance);
+        } else {
+          typeArgs = new List<DartType>.from(arguments.map((n) => n.type));
+        }
+        type = type.instantiate(typeArgs);
+
+        if (staticElement is MethodMember) {
+          MethodMember member = staticElement;
+          staticElement =
+              new MethodMember(member.baseElement, member.definingType, type);
+        } else if (staticElement is MethodElement) {
+          ClassElement clazz = staticElement.enclosingElement;
+          staticElement = new MethodMember(staticElement, clazz.type, type);
+        } else {
+          staticElement =
+              new FunctionMember(staticElement as FunctionElement, type);
+        }
+      }
+    }
+
     staticElement = _convertSetterToGetter(staticElement);
     propagatedElement = _convertSetterToGetter(propagatedElement);
     //
     // Record the results.
     //
     methodName.staticElement = staticElement;
     methodName.propagatedElement = propagatedElement;
     ArgumentList argumentList = node.argumentList;
     if (staticElement != null) {
       List<ParameterElement> parameters =
@@ skipping 1947 matching lines @@
 
   @override
   Element get staticElement => null;
 
   @override
   accept(AstVisitor visitor) => null;
 
   @override
   void visitChildren(AstVisitor visitor) {}
 }