Fix AST-based type inference with explicit type parameters for method calls.

pkg/analyzer/lib/src/summary/link.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.
 
 /**
  * This library is capable of producing linked summaries from unlinked
  * ones (or prelinked ones).  It functions by building a miniature
  * element model to represent the contents of the summaries, and then
  * scanning the element model to gather linked information and adding
  * it to the summary data structures.
@@ skipping 1480 matching lines @@
    * [dependencies].
    */
   void collectDependencies(
       List<ConstNode> dependencies,
       UnlinkedConst unlinkedConst,
       CompilationUnitElementForLink compilationUnit) {
     if (unlinkedConst == null) {
       return;
     }
     int refPtr = 0;
+    int intPtr = 0;
     for (UnlinkedConstOperation operation in unlinkedConst.operations) {
       switch (operation) {
+        case UnlinkedConstOperation.pushInt:
+          intPtr++;
+          break;
+        case UnlinkedConstOperation.pushLongInt:
+          int numInts = unlinkedConst.ints[intPtr++];
+          intPtr += numInts;
+          break;
+        case UnlinkedConstOperation.concatenate:
+          intPtr++;
+          break;
         case UnlinkedConstOperation.pushReference:
+          EntityRef ref = unlinkedConst.references[refPtr++];
+          ConstVariableNode variable =
+              compilationUnit.resolveRef(ref.reference).asConstVariable;
+          if (variable != null) {
+            dependencies.add(variable);
+          }
+          break;
+        case UnlinkedConstOperation.makeUntypedList:
+        case UnlinkedConstOperation.makeUntypedMap:
+          intPtr++;
+          break;
+        case UnlinkedConstOperation.assignToRef:
+          refPtr++;
+          break;
         case UnlinkedConstOperation.invokeMethodRef:
           EntityRef ref = unlinkedConst.references[refPtr++];
           ConstVariableNode variable =
               compilationUnit.resolveRef(ref.reference).asConstVariable;
           if (variable != null) {
             dependencies.add(variable);
           }
+          intPtr += 2;
+          int numTypeArguments = unlinkedConst.ints[intPtr++];
+          refPtr += numTypeArguments;
+          break;
+        case UnlinkedConstOperation.invokeMethod:
+          intPtr += 2;
+          int numTypeArguments = unlinkedConst.ints[intPtr++];
+          refPtr += numTypeArguments;
           break;
         case UnlinkedConstOperation.makeTypedList:
           refPtr++;
+          intPtr++;
           break;
         case UnlinkedConstOperation.makeTypedMap:
           refPtr += 2;
+          intPtr++;
           break;
         case UnlinkedConstOperation.invokeConstructor:
           EntityRef ref = unlinkedConst.references[refPtr++];
           ConstructorElementForLink element =
               compilationUnit.resolveRef(ref.reference).asConstructor;
           if (element?._constNode != null) {
             dependencies.add(element._constNode);
           }
+          intPtr += 2;
+          break;
+        case UnlinkedConstOperation.typeCast:
+        case UnlinkedConstOperation.typeCheck:
+          refPtr++;
+          break;
+        case UnlinkedConstOperation.pushLocalFunctionReference:
+          intPtr += 2;
           break;
         default:
           break;
       }
     }
     assert(refPtr == unlinkedConst.references.length);
+    assert(intPtr == unlinkedConst.ints.length);
   }
 }
 
 /**
  * Instance of [ConstNode] representing a parameter with a default
  * value.
  */
 class ConstParameterNode extends ConstNode {
   /**
    * The [ParameterElement] to which this node refers.
@@ skipping 803 matching lines @@
 
   void _doInvokeMethod() {
     int numNamed = unlinkedConst.ints[intPtr++];
     int numPositional = unlinkedConst.ints[intPtr++];
     List<String> namedArgNames = _getNextStrings(numNamed);
     List<DartType> namedArgTypeList = _popList(numNamed);
     List<DartType> positionalArgTypes = _popList(numPositional);
     // TODO(scheglov) if we pushed target and method name first, we might be
     // able to move work with arguments in _inferExecutableType()
     String methodName = _getNextString();
+    List<DartType> typeArguments = _getTypeArguments();
     DartType target = stack.removeLast();
     stack.add(() {
       if (target is InterfaceType) {
         MethodElement method =
             target.lookUpInheritedMethod(methodName, library: library);
         FunctionType rawType = method?.type;
-        FunctionType inferredType = _inferExecutableType(rawType, numNamed,
-            numPositional, namedArgNames, namedArgTypeList, positionalArgTypes);
+        FunctionType inferredType = _inferExecutableType(
+            rawType,
+            numNamed,
+            numPositional,
+            namedArgNames,
+            namedArgTypeList,
+            positionalArgTypes,
+            typeArguments);
         if (inferredType != null) {
           return inferredType.returnType;
         }
       }
       return DynamicTypeImpl.instance;
     }());
   }
 
   void _doInvokeMethodRef() {
     int numNamed = _getNextInt();
     int numPositional = _getNextInt();
     List<String> namedArgNames = _getNextStrings(numNamed);
     List<DartType> namedArgTypeList = _popList(numNamed);
     List<DartType> positionalArgTypes = _popList(numPositional);
     EntityRef ref = _getNextRef();
     ReferenceableElementForLink element = unit.resolveRef(ref.reference);
+    List<DartType> typeArguments = _getTypeArguments();
     stack.add(() {
       DartType rawType = element.asStaticType;
       if (rawType is FunctionType) {
-        FunctionType inferredType = _inferExecutableType(rawType, numNamed,
-            numPositional, namedArgNames, namedArgTypeList, positionalArgTypes);
+        FunctionType inferredType = _inferExecutableType(
+            rawType,
+            numNamed,
+            numPositional,
+            namedArgNames,
+            namedArgTypeList,
+            positionalArgTypes,
+            typeArguments);
         if (inferredType != null) {
           return inferredType.returnType;
         }
       }
       return DynamicTypeImpl.instance;
     }());
   }
 
   void _doMakeTypedList() {
     DartType itemType = _getNextTypeRef();
@@ skipping 104 matching lines @@
    * resolved.
    */
   DartType _getPropertyType(DartType targetType, String propertyName) {
     return targetType is InterfaceType
         ? targetType
             .lookUpInheritedGetter(propertyName, library: library)
             ?.returnType
         : DynamicTypeImpl.instance;
   }
 
+  List<DartType> _getTypeArguments() {
+    int numTypeArguments = _getNextInt();
+    List<DartType> typeArguments = new List<DartType>(numTypeArguments);
+    for (int i = 0; i < numTypeArguments; i++) {
+      typeArguments[i] = _getNextTypeRef();
+    }
+    return typeArguments;
+  }
+
   FunctionType _inferExecutableType(
       FunctionType rawMethodType,
       int numNamed,
       int numPositional,
       List<String> namedArgNames,
       List<DartType> namedArgTypeList,
-      List<DartType> positionalArgTypes) {
+      List<DartType> positionalArgTypes,
+      List<DartType> typeArguments) {
     TypeSystem ts = linker.typeSystem;
     if (rawMethodType != null) {
-      if (rawMethodType.typeFormals.isNotEmpty && ts is StrongTypeSystemImpl) {
+      if (rawMethodType.typeFormals.isNotEmpty && typeArguments.isNotEmpty) {
+        Element methodElement = rawMethodType.element;
+        if (methodElement is TypeParameterizedElement &&
+            methodElement.typeParameters.length == typeArguments.length) {
+          return rawMethodType.instantiate(typeArguments);
+        }
+      } else if (rawMethodType.typeFormals.isNotEmpty &&
+          ts is StrongTypeSystemImpl) {
         List<DartType> paramTypes = <DartType>[];
         List<DartType> argTypes = <DartType>[];
         // Add positional parameter and argument types.
         for (int i = 0; i < numPositional; i++) {
           ParameterElement parameter = rawMethodType.parameters[i];
           if (parameter != null) {
             paramTypes.add(parameter.type);
             argTypes.add(positionalArgTypes[i]);
           }
         }
@@ skipping 1989 matching lines @@
         case UnlinkedConstOperation.assignToRef:
           // TODO(paulberry): if this reference refers to a variable, should it
           // be considered a type inference dependency?
           refPtr++;
           break;
         case UnlinkedConstOperation.invokeMethodRef:
           // TODO(paulberry): if this reference refers to a variable, should it
           // be considered a type inference dependency?
           refPtr++;
           intPtr += 2;
+          int numTypeArguments = unlinkedConst.ints[intPtr++];
+          refPtr += numTypeArguments;
           break;
         case UnlinkedConstOperation.invokeMethod:
           intPtr += 2;
+          int numTypeArguments = unlinkedConst.ints[intPtr++];
+          refPtr += numTypeArguments;
           break;
         case UnlinkedConstOperation.typeCast:
         case UnlinkedConstOperation.typeCheck:
           refPtr++;
           break;
         case UnlinkedConstOperation.pushLocalFunctionReference:
           int popCount = unlinkedConst.ints[intPtr++];
           assert(popCount == 0); // TODO(paulberry): handle the nonzero case.
           dependencies.add(functionElement
               .getLocalFunction(unlinkedConst.ints[intPtr++])
@@ skipping 334 matching lines @@
    * there are no type parameters in scope.
    */
   TypeParameterizedElementMixin get _typeParameterContext;
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 
   @override
   String toString() => '$enclosingElement.$name';
 }