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 3226 matching lines @@
             int numPositional = unlinkedConst.ints[intPtr++];
             // 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++;
             // TODO(paulberry): implement.
             stack.add(DynamicTypeImpl.instance);
             break;
           case UnlinkedConstOperation.invokeMethod:
-            strPtr++;
             int numNamed = unlinkedConst.ints[intPtr++];
             int numPositional = unlinkedConst.ints[intPtr++];
-            // 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);
+            Map<String, DartType> namedArgTypes = <String, DartType>{};
+            List<DartType> namedArgTypeList = popList(numNamed);
+            for (int i = 0; i < numNamed; i++) {
+              String name = unlinkedConst.strings[strPtr++];
+              DartType type = namedArgTypeList[i];
+              namedArgTypes[name] = type;
+            }
+            List<DartType> positionalArgTypes = popList(numPositional);
+            String methodName = unlinkedConst.strings[strPtr++];
+            DartType target = stack.removeLast();
+            stack.add(() {
+              if (target is InterfaceType) {
+                MethodElement method =
+                    target.lookUpMethod(methodName, libraryElement);
+                DartType rawMethodType = method?.type;
+                TypeSystem ts = linker.typeSystem;
+                if (rawMethodType is FunctionType &&
+                    rawMethodType.typeFormals.isNotEmpty &&

[Paul Berry, 2016/04/09 12:04:29]

This means we won't handle non-generic cases.  Suggestion: change to:

if (rawMethodType is FunctionType) {
  if (rawMethodType.typeFormals.isNotEmpty && ts is StrongTypeSystemImpl) {
    ...
  } else {
    return rawMethodType.returnType;
  }
}

(fine to do this in a follow-up CL if you want)

[scheglov, 2016/04/10 01:29:21]

Thank you, fixed.

+                    ts is StrongTypeSystemImpl) {
+                  List<DartType> paramTypes = <DartType>[];
+                  List<DartType> argTypes = <DartType>[];
+                  for (int i = 0, length = numPositional; i < length; i++) {
+                    ParameterElement parameter = rawMethodType.parameters[i];
+                    if (parameter != null) {
+                      paramTypes.add(parameter.type);
+                      argTypes.add(positionalArgTypes[i]);
+                    }
+                  }
+                  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);
+                    }
+                  });
+                  FunctionType inferred = ts.inferGenericFunctionCall(
+                      typeProvider, rawMethodType, paramTypes, argTypes, null);
+                  return inferred.returnType;
+                }
+              }
+              return DynamicTypeImpl.instance;
+            }());
             break;
           case UnlinkedConstOperation.cascadeSectionBegin:
             stack.add(stack.last);
             break;
           case UnlinkedConstOperation.cascadeSectionEnd:
             stack.removeLast();
             break;
           case UnlinkedConstOperation.typeCast:
             stack.removeLast();
             DartType type = getNextTypeRef();
@@ skipping 413 matching lines @@
           List<int> implicitFunctionTypeIndices) =>
       DynamicTypeImpl.instance;
 
   ReferenceableElementForLink getContainedName(String name) {
     return new NonstaticMemberElementForLink(_constNode);
   }
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }