fix #25425, more inference of generic methods

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 analyzer.src.generated.element_resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
@@ skipping 409 matching lines @@
 
   @override
   Object visitFunctionDeclaration(FunctionDeclaration node) {
     setMetadata(node.element, node);
     return null;
   }
 
   @override
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     Expression function = node.function;
-    DartType staticInvokeType =
-        _resolveGenericMethod(function.staticType, node.typeArguments, node);
-    DartType propagatedInvokeType = _resolveGenericMethod(
+    DartType staticInvokeType = _instantiateGenericMethod(
+        function.staticType, node.typeArguments, node);
+    DartType propagatedInvokeType = _instantiateGenericMethod(
         function.propagatedType, node.typeArguments, node);
 
     node.staticInvokeType = staticInvokeType;
     node.propagatedInvokeType =
         _propagatedInvokeTypeIfBetter(propagatedInvokeType, staticInvokeType);
 
     List<ParameterElement> parameters =
         _computeCorrespondingParameters(node.argumentList, staticInvokeType);
     if (parameters != null) {
       node.argumentList.correspondingStaticParameters = parameters;
@@ skipping 202 matching lines @@
         if (propagatedType is InterfaceType) {
           propagatedElement = _resolveInvokedElementWithTarget(
               target, propagatedType, methodName, isConditional);
         }
       }
     }
 
     staticElement = _convertSetterToGetter(staticElement);
     propagatedElement = _convertSetterToGetter(propagatedElement);
 
-    DartType staticInvokeType = _computeMethodInvokeType(node, staticElement);
-    DartType propagatedInvokeType =
-        _computeMethodInvokeType(node, propagatedElement);
+    //
+    // Given the elements, determine the type of the function we are invoking
+    //
+    DartType staticInvokeType = _getInvokeType(staticElement);
+    methodName.staticType = staticInvokeType;

[Jennifer Messerly, 2016/01/13 22:32:46]

This stores the element's type in the methodName node. We were already doing
that for variables, and in strong mode we used to do it always. This just makes
it happen always for consistency and ease of use for resolved ASTs.

Note, this change is not strictly necessary. We could put "getInvokeType" on
Resolver and call it from ElementResolver and StaticTypeAnalyzer. I actually
started down that route, but then recalled discussions yesterday and Leaf's
prodding, which led me to just populate it in the AST.

+
+    DartType propagatedInvokeType = _getInvokeType(propagatedElement);
+    methodName.propagatedType =
+        _propagatedInvokeTypeIfBetter(propagatedInvokeType, staticInvokeType);
+
+    //
+    // Instantiate generic function or method if needed.
+    //
+    staticInvokeType = _instantiateGenericMethod(
+        staticInvokeType, node.typeArguments, node.methodName);
+    propagatedInvokeType = _instantiateGenericMethod(
+        propagatedInvokeType, node.typeArguments, node.methodName);
 
     //
     // Record the results.
     //
     methodName.staticElement = staticElement;
     methodName.propagatedElement = propagatedElement;
 
     node.staticInvokeType = staticInvokeType;
     //
     // Store the propagated invoke type if it's more specific than the static
@@ skipping 663 matching lines @@
       if (callMethod != null) {
         return _resolveArgumentsToFunction(false, argumentList, callMethod);
       }
     } else if (type is FunctionType) {
       return _resolveArgumentsToParameters(
           false, argumentList, type.parameters);
     }
     return null;
   }
 
-  DartType _computeMethodInvokeType(MethodInvocation node, Element element) {
-    if (element == null) {
-      // TODO(jmesserly): should we return `dynamic` in this case?
-      // Otherwise we have to guard against `null` every time we use
-      // `staticInvokeType`.
-      // If we do return `dynamic` we need to be careful that this doesn't
-      // adversely affect propagatedType code path. But it shouldn't because
-      // we'll discard `dynamic` anyway (see _propagatedInvokeTypeIfBetter).
-      return null;
-    }
-
+  /**
+   * Given an element, computes the type of the invocation.
+   *
+   * For executable elements (like methods, functions) this is just their type.
+   * For variables it is their type taking into account any type promotion.
+   * For getters it is the type that they return.
+   */
+  DartType _getInvokeType(Element element) {
     DartType invokeType;
     if (element is PropertyAccessorElement) {
       invokeType = element.returnType;
     } else if (element is ExecutableElement) {
       invokeType = element.type;
     } else if (element is VariableElement) {
       invokeType = _promoteManager.getStaticType(element);
     }
-
-    return _resolveGenericMethod(
-        invokeType, node.typeArguments, node.methodName);
+    return invokeType ?? DynamicTypeImpl.instance;
   }
 
   /**
    * If the given [element] is a setter, return the getter associated with it.
    * Otherwise, return the element unchanged.
    */
   Element _convertSetterToGetter(Element element) {
     // TODO(brianwilkerson) Determine whether and why the element could ever be
     // a setter.
     if (element is PropertyAccessorElement) {
@@ skipping 705 matching lines @@
     }
     if (element != null && element.isAccessibleIn(_definingLibrary)) {
       return element;
     }
     return null;
   }
 
   /**
    * Check for a generic method & apply type arguments if any were passed.
    */
-  DartType _resolveGenericMethod(
+  DartType _instantiateGenericMethod(
       DartType invokeType, TypeArgumentList typeArguments, AstNode node) {
     // TODO(jmesserly): support generic "call" methods on InterfaceType.
     if (invokeType is FunctionType) {
       FunctionType type = invokeType;
       List<TypeParameterElement> parameters = type.typeFormals;
 
       NodeList<TypeName> arguments = typeArguments?.arguments;
       if (arguments != null && arguments.length != parameters.length) {
         // Wrong number of type arguments. Ignore them
         arguments = null;
@@ skipping 510 matching lines @@
 
   @override
   Element get staticElement => null;
 
   @override
   accept(AstVisitor visitor) => null;
 
   @override
   void visitChildren(AstVisitor visitor) {}
 }