Infer generic method invocation type.

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 1833 matching lines @@
       stack.add(DynamicTypeImpl.instance);
     } else {
       stack.removeLast();
       // TODO(scheglov) implement
       stack.add(DynamicTypeImpl.instance);
     }
   }
 
   void _doAssignToProperty() {
     DartType targetType = stack.removeLast();
-    String propertyName = unlinkedConst.strings[strPtr++];
+    String propertyName = _getNextString();
     UnlinkedExprAssignOperator assignOperator =
         unlinkedConst.assignmentOperators[assignmentOperatorPtr++];
     if (assignOperator == UnlinkedExprAssignOperator.assign) {
       // The type of the assignment is the type of the value,
       // which is already in the stack.
     } else if (assignOperator == UnlinkedExprAssignOperator.postfixDecrement ||
         assignOperator == UnlinkedExprAssignOperator.postfixIncrement) {
       DartType propertyType = _getPropertyType(targetType, propertyName);
       stack.add(propertyType);
     } else if (assignOperator == UnlinkedExprAssignOperator.prefixDecrement) {
@@ skipping 32 matching lines @@
     DartType elseType = stack.removeLast();
     DartType thenType = stack.removeLast();
     stack.removeLast();
     DartType type = _leastUpperBound(thenType, elseType);
     type = _dynamicIfNull(type);
     stack.add(type);
   }
 
   void _doExtractProperty() {
     DartType target = stack.removeLast();
-    String propertyName = unlinkedConst.strings[strPtr++];
+    String propertyName = _getNextString();
     stack.add(() {
       if (target is InterfaceType) {
         PropertyAccessorElement getter =
             target.lookUpGetter(propertyName, library);
         if (getter != null) {
           return getter.returnType;
         }
         MethodElement method = target.lookUpMethod(propertyName, library);
         if (method != null) {
           return method.type;
@@ skipping 19 matching lines @@
               ? DynamicTypeImpl.instance
               : unit._resolveTypeRef(
                   ref.typeArguments[i], variable._typeParameterContext),
           const []));
     } else {
       stack.add(DynamicTypeImpl.instance);
     }
   }
 
   void _doInvokeMethod() {
-    strPtr++;
-    int numNamed = _getNextInt();
-    int numPositional = _getNextInt();
-    // TODO(paulberry): don't just pop the args; use their types
-    // to infer the type of type arguments.
-    stack.length -= numNamed + numPositional;
-    strPtr += numNamed;
-    stack.removeLast();
-    // TODO(paulberry): implement.
-    stack.add(DynamicTypeImpl.instance);
+    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);
+    String methodName = _getNextString();
+    DartType target = stack.removeLast();
+    stack.add(() {
+      if (target is InterfaceType) {
+        MethodElement method = target.lookUpMethod(methodName, library);
+        DartType rawMethodType = method?.type;
+        TypeSystem ts = linker.typeSystem;
+        if (rawMethodType is FunctionType) {
+          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]);
+              }
+            }
+            // Prepare named argument types map.
+            Map<String, DartType> namedArgTypes = <String, DartType>{};
+            for (int i = 0; i < numNamed; i++) {
+              String name = namedArgNames[i];
+              DartType type = namedArgTypeList[i];
+              namedArgTypes[name] = type;
+            }
+            // Add named parameter and argument types.
+            Map<String, DartType> namedParameterTypes =
+                rawMethodType.namedParameterTypes;
+            namedArgTypes.forEach((String name, DartType argType) {
+              DartType parameterType = namedParameterTypes[name];
+              if (parameterType != null) {
+                paramTypes.add(parameterType);
+                argTypes.add(argType);
+              }
+            });
+            // Perform inference.
+            FunctionType inferred = ts.inferGenericFunctionCall(
+                typeProvider, rawMethodType, paramTypes, argTypes, null);
+            return inferred.returnType;
+          }
+          // Not a generic method, use the raw return type.
+          return rawMethodType.returnType;
+        }
+      }
+      return DynamicTypeImpl.instance;
+    }());
   }
 
   void _doInvokeMethodRef() {
     int numNamed = _getNextInt();
     int numPositional = _getNextInt();
     // TODO(paulberry): don't just pop the args; use their types
     // to infer the type of type arguments.
     stack.length -= numNamed + numPositional;
     strPtr += numNamed;
     refPtr++;
@@ skipping 60 matching lines @@
       } else {
         stack.add(element.asStaticType);
       }
     }
   }
 
   int _getNextInt() {
     return unlinkedConst.ints[intPtr++];
   }
 
+  String _getNextString() {
+    return unlinkedConst.strings[strPtr++];
+  }
+
+  List<String> _getNextStrings(int n) {
+    List<String> result = new List<String>(n);
+    for (int i = 0; i < n; i++) {
+      result[i] = _getNextString();
+    }
+    return result;
+  }
+
   DartType _getNextTypeRef() {
     EntityRef ref = unlinkedConst.references[refPtr++];
     return unit._resolveTypeRef(ref, variable._typeParameterContext);
   }
 
   /**
    * Return the type of the property with the given [propertyName] in the
    * given [targetType]. May return `dynamic` if the property cannot be
    * resolved.
    */
@@ skipping 1753 matching lines @@
           List<int> implicitFunctionTypeIndices) =>
       DynamicTypeImpl.instance;
 
   ReferenceableElementForLink getContainedName(String name) {
     return new NonstaticMemberElementForLink(_constNode);
   }
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }