Link invocation of method references, with inference.

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 2024 matching lines @@
       stack.add(DynamicTypeImpl.instance);
     }
   }
 
   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();
     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;
+        FunctionType rawType = method?.type;
+        FunctionType inferredType = _inferExecutableType(rawType, numNamed,
+            numPositional, namedArgNames, namedArgTypeList, positionalArgTypes);
+        if (inferredType != null) {
+          return inferredType.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++;
-    // TODO(paulberry): implement.
-    stack.add(DynamicTypeImpl.instance);
+    List<String> namedArgNames = _getNextStrings(numNamed);
+    List<DartType> namedArgTypeList = _popList(numNamed);
+    List<DartType> positionalArgTypes = _popList(numPositional);
+    EntityRef ref = unlinkedConst.references[refPtr++];
+    ReferenceableElementForLink element = unit._resolveRef(ref.reference);
+    stack.add(() {
+      DartType rawType = element.asStaticType;
+      if (rawType is FunctionType) {
+        FunctionType inferredType = _inferExecutableType(rawType, numNamed,
+            numPositional, namedArgNames, namedArgTypeList, positionalArgTypes);
+        if (inferredType != null) {
+          return inferredType.returnType;
+        }
+      }
+      return DynamicTypeImpl.instance;
+    }());
   }
 
   void _doMakeTypedList() {
     DartType itemType = _getNextTypeRef();
     stack.length -= _getNextInt();
     stack.add(typeProvider.listType.instantiate(<DartType>[itemType]));
   }
 
   void _doMakeTypeMap() {
     DartType keyType = _getNextTypeRef();
@@ skipping 72 matching lines @@
    * Return the type of the property with the given [propertyName] in the
    * given [targetType]. May return `dynamic` if the property cannot be
    * resolved.
    */
   DartType _getPropertyType(DartType targetType, String propertyName) {
     return targetType is InterfaceType
         ? targetType.lookUpGetter(propertyName, library)?.returnType
         : DynamicTypeImpl.instance;
   }
 
+  FunctionType _inferExecutableType(
+      FunctionType rawMethodType,
+      int numNamed,
+      int numPositional,
+      List<String> namedArgNames,
+      List<DartType> namedArgTypeList,
+      List<DartType> positionalArgTypes) {
+    TypeSystem ts = linker.typeSystem;
+    if (rawMethodType != null) {
+      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;
+      }
+    }
+    // Not a generic function type, use the raw type.
+    return rawMethodType;
+  }
+
   DartType _leastUpperBound(DartType s, DartType t) {
     return linker.typeSystem.getLeastUpperBound(typeProvider, s, t);
   }
 
   List<DartType> _popList(int n) {
     List<DartType> result = stack.sublist(stack.length - n, stack.length);
     stack.length -= n;
     return result;
   }
 
@@ skipping 1970 matching lines @@
       if (type is InterfaceType) {
         Element result = type.lookUpGetter(name, compilationUnit.library);
         result ??= type.lookUpMethod(name, compilationUnit.library);
         return result;
       }
     }
     // TODO(scheglov): implement for propagated types
     return null;
   }
 }