Add an analyzer option to properly check ".call" 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 engine.resolver.element_resolver;
 
 import 'dart:collection';
 
 import 'ast.dart';
 import 'element.dart';
@@ skipping 63 matching lines @@
    * The element for the library containing the compilation unit being visited.
    */
   LibraryElement _definingLibrary;
 
   /**
    * A flag indicating whether we should generate hints.
    */
   bool _enableHints = false;
 
   /**
+   * A flag indicating whether we should strictly follow the specification when
+   * generating warnings on "call" methods (fixes dartbug.com/21938).
+   */
+  bool _enableStrictCallChecks = false;
+
+  /**
    * The type representing the type 'dynamic'.
    */
   DartType _dynamicType;
 
   /**
    * The type representing the type 'type'.
    */
   DartType _typeType;
 
   /**
    * A utility class for the resolver to answer the question of "what are my subtypes?".
    */
   SubtypeManager _subtypeManager;
 
   /**
    * The object keeping track of which elements have had their types promoted.
    */
   TypePromotionManager _promoteManager;
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param resolver the resolver driving this participant
    */
   ElementResolver(this._resolver) {
     this._definingLibrary = _resolver.definingLibrary;
     AnalysisOptions options = _definingLibrary.context.analysisOptions;
     _enableHints = options.hint;
+    _enableStrictCallChecks = options.enableStrictCallChecks;
     _dynamicType = _resolver.typeProvider.dynamicType;
     _typeType = _resolver.typeProvider.typeType;
     _subtypeManager = new SubtypeManager();
     _promoteManager = _resolver.promoteManager;
   }
 
   /**
    * @return `true` iff current enclosing function is constant constructor declaration.
    */
   bool get isInConstConstructor {
@@ skipping 566 matching lines @@
         DartType targetType = null;
         if (!generatedWithTypePropagation) {
           targetType = _getStaticType(target);
         } else {
           // choose the best type
           targetType = _getPropagatedType(target);
           if (targetType == null) {
             targetType = _getStaticType(target);
           }
         }
-        if (targetType != null &&
+        if (!_enableStrictCallChecks &&
+            targetType != null &&
             targetType.isDartCoreFunction &&
             methodName.name == FunctionElement.CALL_METHOD_NAME) {
           // TODO(brianwilkerson) Can we ever resolve the function being
           // invoked?
 //          resolveArgumentsToParameters(node.getArgumentList(), invokedFunction);
           return null;
         }
         targetTypeName = targetType == null ? null : targetType.displayName;
         ErrorCode proxyErrorCode = (generatedWithTypePropagation
             ? HintCode.UNDEFINED_METHOD
@@ skipping 756 matching lines @@
   }
 
   /**
    * Return `true` if the given type represents an object that could be invoked using the call
    * operator '()'.
    *
    * @param type the type being tested
    * @return `true` if the given type represents an object that could be invoked
    */
   bool _isExecutableType(DartType type) {
-    if (type.isDynamic ||
-        (type is FunctionType) ||
-        type.isDartCoreFunction ||
-        type.isObject) {
+    if (type.isDynamic || type is FunctionType) {
+      return true;
+    } else if (!_enableStrictCallChecks &&
+        (type.isDartCoreFunction || type.isObject)) {
       return true;
     } else if (type is InterfaceType) {
       ClassElement classElement = type.element;
       // 16078 from Gilad: If the type is a Functor with the @proxy annotation,
       // treat it as an executable type.
       // example code: NonErrorResolverTest.
       // test_invocationOfNonFunction_proxyOnFunctionClass()
       if (classElement.isProxy &&
           type.isSubtypeOf(_resolver.typeProvider.functionType)) {
         return true;
@@ skipping 1083 matching lines @@
       bool isStaticProperty = _isStatic(staticOrPropagatedEnclosingElt);
       DartType displayType = staticOrPropagatedType != null
           ? staticOrPropagatedType
           : propagatedType != null ? propagatedType : staticType;
       // Special getter cases.
       if (propertyName.inGetterContext()) {
         if (!isStaticProperty &&
             staticOrPropagatedEnclosingElt is ClassElement) {
           ClassElement classElement = staticOrPropagatedEnclosingElt;
           InterfaceType targetType = classElement.type;
-          if (targetType != null &&
+          if (!_enableStrictCallChecks &&
+              targetType != null &&
               targetType.isDartCoreFunction &&
               propertyName.name == FunctionElement.CALL_METHOD_NAME) {
             // TODO(brianwilkerson) Can we ever resolve the function being
             // invoked?
 //            resolveArgumentsToParameters(node.getArgumentList(), invokedFunction);
             return;
           } else if (classElement.isEnum && propertyName.name == "_name") {
             _resolver.reportErrorForNode(
                 CompileTimeErrorCode.ACCESS_PRIVATE_ENUM_FIELD, propertyName, [
               propertyName.name
@@ skipping 420 matching lines @@
 
   @override
   Element get staticElement => null;
 
   @override
   accept(AstVisitor visitor) => null;
 
   @override
   void visitChildren(AstVisitor visitor) {}
 }