fix #26812, function types should support the call method

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/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 625 matching lines @@
       // does not apply to conditional method invocation (i.e. 'C?.m(...)').
       //
       bool isConditional = node.operator.type == TokenType.QUESTION_PERIOD;
       ClassElement typeReference = getTypeReference(target);
       if (typeReference != null) {
         if (node.isCascaded) {
           typeReference = _typeType.element;
         }
         staticElement = _resolveElement(typeReference, methodName);
       } else {
-        DartType staticType = _getStaticType(target);
+        DartType staticType = _resolver.strongMode
+            ? _getStaticTypeOrFunctionType(target)
+            : _getStaticType(target);
         DartType propagatedType = _getPropagatedType(target);
         staticElement = _resolveInvokedElementWithTarget(
             target, staticType, methodName, isConditional);
         // If we have propagated type information use it (since it should
         // not be redundant with the staticType).  Otherwise, don't produce
         // a propagatedElement which duplicates the staticElement.
         if (propagatedType is InterfaceType) {
           propagatedElement = _resolveInvokedElementWithTarget(
               target, propagatedType, methodName, isConditional);
         }
@@ skipping 153 matching lines @@
     } else if (identical(
         errorCode, StaticTypeWarningCode.UNDEFINED_SUPER_METHOD)) {
       // Generate the type name.
       // The error code will never be generated via type propagation
       DartType getSuperType(DartType type) {
         if (type is InterfaceType && !type.isObject) {
           return type.superclass;
         }
         return type;
       }
+
       DartType targetType = getSuperType(_getStaticType(target));
       String targetTypeName = targetType?.name;
       _resolver.errorReporter.reportErrorForNode(
           StaticTypeWarningCode.UNDEFINED_SUPER_METHOD,
           methodName,
           [methodName.name, targetTypeName]);
     }
     return null;
   }
 
@@ skipping 679 matching lines @@
       propagatedType = _resolver.typeProvider.functionType;
     }
     return propagatedType;
   }
 
   /**
    * Return the static type of the given [expression] that is to be used for
    * type analysis.
    */
   DartType _getStaticType(Expression expression) {
-    if (expression is NullLiteral) {
-      return _resolver.typeProvider.bottomType;
-    }
-    DartType staticType = _resolveTypeParameter(expression.staticType);
+    DartType staticType = _getStaticTypeOrFunctionType(expression);
     if (staticType is FunctionType) {
       //
       // All function types are subtypes of 'Function', which is itself a
       // subclass of 'Object'.
       //
       staticType = _resolver.typeProvider.functionType;

[Jennifer Messerly, 2016/08/09 17:14:21]

... wow

[Leaf, 2016/08/10 07:38:14]

Wat?  Am I crazy, or does this mean that everything is completely broken
everywhere? 

[Jennifer Messerly, 2016/08/10 15:27:45]

yeah it's *super* scary. I looked a bit yesterday... and it seems mostly safe:
unary/binary/opassign ops, index expression, and super calls, which aren't
supported for function types. One place that's probably broken is property get
(tear-offs) if you're allowed to tear off the ".call" method from functions. I
didn't get a chance to dig into that one.

I actually tried at first guarding the code against !strongMode on this line,
but that broke some of the places where they special case "isDartCoreFunction". 
For example, the == path got busted and it didn't know you could compare
functions for equality. Wasn't sure how long that bug trail would go.

There are other strange things in here too, like FunctionExpressionInvocation
where it just uses ".staticType" ... not sure if that's right either given the
"_resolveTypeParameter" call below.

But yeah I can file a bug. It certainly felt like uncovering a skeleton in the
closet :)

     }
     return staticType;
   }
 
+  DartType _getStaticTypeOrFunctionType(Expression expression) {
+    if (expression is NullLiteral) {
+      return _resolver.typeProvider.bottomType;
+    }
+    return _resolveTypeParameter(expression.staticType);
+  }
+
   /**
    * Check for a generic method & apply type arguments if any were passed.
    */
   DartType _instantiateGenericMethod(
       DartType invokeType, TypeArgumentList typeArguments, AstNode node) {
     // TODO(jmesserly): support generic "call" methods on InterfaceType.
     if (invokeType is FunctionType) {
       List<TypeParameterElement> parameters = invokeType.typeFormals;
 
       NodeList<TypeName> arguments = typeArguments?.arguments;
@@ skipping 646 matching lines @@
         // If there's no method, then it's possible that 'm' is a getter that
         // returns a function.
         //
         // TODO (collinsn): need to add union type support here too, in the
         // style of [lookUpMethod].
         element = _lookUpGetter(target, targetType, methodName.name);
       }
       return element;
     } else if (target is SimpleIdentifier) {
       Element targetElement = target.staticElement;
+      if (targetType is FunctionType &&
+          methodName.name == FunctionElement.CALL_METHOD_NAME) {
+        return targetElement;
+      }
       if (targetElement is PrefixElement) {
         if (isConditional) {
           _resolver.errorReporter.reportErrorForNode(
               CompileTimeErrorCode.PREFIX_IDENTIFIER_NOT_FOLLOWED_BY_DOT,
               target,
               [target.name]);
         }
         //
         // Look to see whether the name of the method is really part of a
         // prefixed identifier for an imported top-level function or top-level
@@ skipping 383 matching lines @@
 
   @override
   Element get staticElement => null;
 
   @override
   dynamic/*=E*/ accept/*<E>*/(AstVisitor/*<E>*/ visitor) => null;
 
   @override
   void visitChildren(AstVisitor visitor) {}
 }