Handle type parameters correctly when generating hints (issue 23243)

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 engine.resolver.element_resolver;
 
 import 'dart:collection';
 
 import 'ast.dart';
 import 'element.dart';
@@ skipping 633 matching lines @@
     bool generatedWithTypePropagation = false;
     if (_enableHints && errorCode == null && staticElement == null) {
       // The method lookup may have failed because there were multiple
       // incompatible choices. In this case we don't want to generate a hint.
       errorCode = _checkForInvocationError(target, false, propagatedElement);
       if (identical(errorCode, StaticTypeWarningCode.UNDEFINED_METHOD)) {
         ClassElement classElementContext = null;
         if (target == null) {
           classElementContext = _resolver.enclosingClass;
         } else {
-          DartType type = target.bestType;
+          DartType type = _getBestType(target);
           if (type != null) {
             if (type.element is ClassElement) {
               classElementContext = type.element as ClassElement;
             }
           }
         }
         if (classElementContext != null) {
           _subtypeManager.ensureLibraryVisited(_definingLibrary);
           HashSet<ClassElement> subtypeElements =
               _subtypeManager.computeAllSubtypes(classElementContext);
@@ skipping 518 matching lines @@
             return StaticTypeWarningCode.INVOCATION_OF_NON_FUNCTION;
           }
         } else {
           DartType targetType;
           if (useStaticContext) {
             targetType = _getStaticType(target);
           } else {
             // Compute and use the propagated type, if it is null, then it may
             // be the case that static type is some type, in which the static
             // type should be used.
-            targetType = target.bestType;
+            targetType = _getBestType(target);
           }
           if (targetType == null) {
             return StaticTypeWarningCode.UNDEFINED_FUNCTION;
           } else if (!targetType.isDynamic && !targetType.isBottom) {
             // Proxy-conditional warning, based on state of
             // targetType.getElement()
             return StaticTypeWarningCode.UNDEFINED_METHOD;
           }
         }
       }
@@ skipping 181 matching lines @@
     } else if (operatorType == sc.TokenType.MINUS_MINUS) {
       return sc.TokenType.MINUS.lexeme;
     } else if (operatorType == sc.TokenType.MINUS) {
       return "unary-";
     } else {
       return operator.lexeme;
     }
   }
 
   /**
+   * Return the best type of the given [expression] that is to be used for
+   * type analysis.
+   */
+  DartType _getBestType(Expression expression) {
+    DartType bestType = _resolveTypeParameter(expression.bestType);
+    if (bestType is FunctionType) {
+      //
+      // All function types are subtypes of 'Function', which is itself a
+      // subclass of 'Object'.
+      //
+      bestType = _resolver.typeProvider.functionType;
+    }
+    return bestType;
+  }
+
+  /**
    * Return the propagated type of the given [expression] that is to be used for
    * type analysis.
    */
   DartType _getPropagatedType(Expression expression) {
     DartType propagatedType = _resolveTypeParameter(expression.propagatedType);
     if (propagatedType is FunctionType) {
       //
       // All function types are subtypes of 'Function', which is itself a
       // subclass of 'Object'.
       //
@@ skipping 1371 matching lines @@
 
   @override
   Element get staticElement => null;
 
   @override
   accept(AstVisitor visitor) => null;
 
   @override
   void visitChildren(AstVisitor visitor) {}
 }