Correctly compute whether a class subclasses Function (issue 22805)

pkg/analyzer/lib/src/generated/element.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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.element;
 
 import 'dart:collection';
@@ skipping 3283 matching lines @@
 }
 
 /**
  * A base class for concrete implementations of an [ExecutableElement].
  */
 abstract class ExecutableElementImpl extends ElementImpl
     implements ExecutableElement {
   /**
    * An empty list of executable elements.
    */
-  static const List<ExecutableElement> EMPTY_ARRAY = const <ExecutableElement>[
-  ];
+  static const List<ExecutableElement> EMPTY_ARRAY =
+      const <ExecutableElement>[];
 
   /**
    * A list containing all of the functions defined within this executable
    * element.
    */
   List<FunctionElement> _functions = FunctionElementImpl.EMPTY_ARRAY;
 
   /**
    * A list containing all of the labels defined within this executable element.
    */
@@ skipping 2035 matching lines @@
 abstract class HtmlScriptElement implements Element {}
 
 /**
  * A concrete implementation of an [HtmlScriptElement].
  */
 abstract class HtmlScriptElementImpl extends ElementImpl
     implements HtmlScriptElement {
   /**
    * An empty list of HTML script elements.
    */
-  static const List<HtmlScriptElement> EMPTY_ARRAY = const <HtmlScriptElement>[
-  ];
+  static const List<HtmlScriptElement> EMPTY_ARRAY =
+      const <HtmlScriptElement>[];
 
   /**
    * Initialize a newly created script element corresponding to the given
    * [node].
    */
   HtmlScriptElementImpl(XmlTagNode node)
       : super(node.tag, node.tagToken.offset);
 }
 
 /**
@@ skipping 1107 matching lines @@
       }
       for (int i = 0; i < typeTArgs.length; i++) {
         // Recursively call isSubtypeOf the type arguments and return false if
         // the T argument is not a subtype of the S argument.
         if (!(typeTArgs[i] as TypeImpl).isSubtypeOf2(
             typeSArgs[i], visitedTypePairs)) {
           return false;
         }
       }
       return true;
-    } else if (typeS.isDartCoreFunction && elementT.getMethod("call") != null) {
+    } else if (typeS.isDartCoreFunction && _hasCallMethod(elementT)) {
       return true;
     }
     InterfaceType supertype = superclass;
     // The type is Object, return false.
     if (supertype != null &&
         (supertype as InterfaceTypeImpl)._isSubtypeOf(
             typeS, visitedClasses, visitedTypePairs)) {
       return true;
     }
     List<InterfaceType> interfaceTypes = interfaces;
     for (InterfaceType interfaceType in interfaceTypes) {
       if ((interfaceType as InterfaceTypeImpl)._isSubtypeOf(
           typeS, visitedClasses, visitedTypePairs)) {
         return true;
       }
     }
     List<InterfaceType> mixinTypes = mixins;
     for (InterfaceType mixinType in mixinTypes) {
       if ((mixinType as InterfaceTypeImpl)._isSubtypeOf(
           typeS, visitedClasses, visitedTypePairs)) {
         return true;
       }
     }
     return false;
   }
 
   /**
+   * Return `true` if the given element has an instance method named 'call'.
+   */
+  bool _hasCallMethod(ClassElement elementT) {
+    MethodElement method = elementT.lookUpMethod(
+        FunctionElement.CALL_METHOD_NAME, elementT.library);
+    return method != null && !method.isStatic;
+  }
+
+  /**
    * Return the length of the longest inheritance path from the given [type] to
    * Object.
    *
    * See [InterfaceType.getLeastUpperBound].
    */
   static int computeLongestInheritancePathToObject(InterfaceType type) =>
       _computeLongestInheritancePathToObject(
           type, 0, new HashSet<ClassElement>());
 
   /**
@@ skipping 3155 matching lines @@
   TypeParameterElement get element;
 }
 
 /**
  * A concrete implementation of a [TypeParameterType].
  */
 class TypeParameterTypeImpl extends TypeImpl implements TypeParameterType {
   /**
    * An empty list of type parameter types.
    */
-  static const List<TypeParameterType> EMPTY_ARRAY = const <TypeParameterType>[
-  ];
+  static const List<TypeParameterType> EMPTY_ARRAY =
+      const <TypeParameterType>[];
 
   /**
    * Initialize a newly created type parameter type to be declared by the given
    * [element] and to have the given name.
    */
   TypeParameterTypeImpl(TypeParameterElement element)
       : super(element, element.name);
 
   @override
   TypeParameterElement get element => super.element as TypeParameterElement;
@@ skipping 718 matching lines @@
     // void <: void (by reflexivity)
     // bottom <: void (as bottom is a subtype of all types).
     // void <: dynamic (as dynamic is a supertype of all types)
     return identical(type, this) || type.isDynamic;
   }
 
   @override
   VoidTypeImpl substitute2(
       List<DartType> argumentTypes, List<DartType> parameterTypes) => this;
 }