Correctly compute whether a class subclasses Function (issue 22805)

pkg/analyzer/lib/src/generated/error_verifier.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.error_verifier;
 
 import "dart:math" as math;
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/static_type_analyzer.dart';
@@ skipping 1087 matching lines @@
    * See [StaticTypeWarningCode.EXPECTED_TWO_MAP_TYPE_ARGUMENTS].
    */
   bool _checkExpectedTwoMapTypeArguments(TypeArgumentList typeArguments) {
     // check number of type arguments
     int num = typeArguments.arguments.length;
     if (num == 2) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        StaticTypeWarningCode.EXPECTED_TWO_MAP_TYPE_ARGUMENTS, typeArguments, [
-      num
-    ]);
+        StaticTypeWarningCode.EXPECTED_TWO_MAP_TYPE_ARGUMENTS, typeArguments,
+        [num]);
     return true;
   }
 
   /**
    * This verifies that the passed constructor declaration does not violate any of the error codes
    * relating to the initialization of fields in the enclosing class.
    *
    * @param node the [ConstructorDeclaration] to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [_initialFieldElementsMap],
@@ skipping 79 matching lines @@
           }
         }
       }
     }
     // Visit all of the states in the map to ensure that none were never
     // initialized.
     fieldElementsMap.forEach((FieldElement fieldElement, INIT_STATE state) {
       if (state == INIT_STATE.NOT_INIT) {
         if (fieldElement.isConst) {
           _errorReporter.reportErrorForNode(
-              CompileTimeErrorCode.CONST_NOT_INITIALIZED, node.returnType, [
-            fieldElement.name
-          ]);
+              CompileTimeErrorCode.CONST_NOT_INITIALIZED, node.returnType,
+              [fieldElement.name]);
           foundError = true;
         } else if (fieldElement.isFinal) {
           _errorReporter.reportErrorForNode(
-              StaticWarningCode.FINAL_NOT_INITIALIZED, node.returnType, [
-            fieldElement.name
-          ]);
+              StaticWarningCode.FINAL_NOT_INITIALIZED, node.returnType,
+              [fieldElement.name]);
           foundError = true;
         }
       }
     });
     return foundError;
   }
 
   /**
    * This checks the passed executable element against override-error codes.
    *
@@ skipping 445 matching lines @@
         //
         // Prepare the constructor name
         //
         String constructorStrName = constructorTypeName.name.name;
         if (redirectedConstructor.name != null) {
           constructorStrName += ".${redirectedConstructor.name.name}";
         }
         ErrorCode errorCode = (node.constKeyword != null
             ? CompileTimeErrorCode.REDIRECT_TO_MISSING_CONSTRUCTOR
             : StaticWarningCode.REDIRECT_TO_MISSING_CONSTRUCTOR);
-        _errorReporter.reportErrorForNode(errorCode, redirectedConstructor,
-            [constructorStrName, redirectedType.displayName]);
+        _errorReporter.reportErrorForNode(errorCode, redirectedConstructor, [
+          constructorStrName,
+          redirectedType.displayName
+        ]);
         return true;
       }
       return false;
     }
     FunctionType redirectedType = redirectedElement.type;
     DartType redirectedReturnType = redirectedType.returnType;
     //
     // Report specific problem when return type is incompatible
     //
     FunctionType constructorType = node.element.type;
@@ skipping 53 matching lines @@
       return true;
     }
     // RETURN_WITHOUT_VALUE
     if (returnExpression == null) {
       if (_inGenerator ||
           _computeReturnTypeForMethod(null)
               .isAssignableTo(expectedReturnType)) {
         return false;
       }
       _hasReturnWithoutValue = true;
-      _errorReporter
-          .reportErrorForNode(StaticWarningCode.RETURN_WITHOUT_VALUE, node);
+      _errorReporter.reportErrorForNode(
+          StaticWarningCode.RETURN_WITHOUT_VALUE, node);
       return true;
     } else if (_inGenerator) {
       // RETURN_IN_GENERATOR
-      _errorReporter
-          .reportErrorForNode(CompileTimeErrorCode.RETURN_IN_GENERATOR, node);
+      _errorReporter.reportErrorForNode(
+          CompileTimeErrorCode.RETURN_IN_GENERATOR, node);
     }
     // RETURN_OF_INVALID_TYPE
     return _checkForReturnOfInvalidType(returnExpression, expectedReturnType);
   }
 
   /**
    * This verifies that the export namespace of the passed export directive does not export any name
    * already exported by other export directive.
    *
    * @param node the export directive node to report problem on
@@ skipping 383 matching lines @@
       }
     }
     // conflict with class member
     if (constructorName != null &&
         constructorElement != null &&
         !constructorName.isSynthetic) {
       // fields
       FieldElement field = classElement.getField(name);
       if (field != null) {
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD, node, [
-          name
-        ]);
+            CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD, node,
+            [name]);
         return true;
       }
       // methods
       MethodElement method = classElement.getMethod(name);
       if (method != null) {
         _errorReporter.reportErrorForNode(
             CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD, node,
             [name]);
         return true;
       }
@@ skipping 197 matching lines @@
             addThisMemberToTheMap = false;
           }
         } else if (isSetter) {
           String methodName = name.name;
           ClassMember conflictingMethod = memberHashMap[methodName];
           if (conflictingMethod != null &&
               conflictingMethod is MethodDeclaration &&
               !conflictingMethod.isGetter) {
             // report problem
             _errorReporter.reportErrorForNode(
-                StaticWarningCode.CONFLICTING_INSTANCE_METHOD_SETTER2, name,
-                [_enclosingClass.displayName, name.name]);
+                StaticWarningCode.CONFLICTING_INSTANCE_METHOD_SETTER2, name, [
+              _enclosingClass.displayName,
+              name.name
+            ]);
             foundError = true;
             addThisMemberToTheMap = false;
           }
         }
         // Finally, add this member into the HashMap.
         if (addThisMemberToTheMap) {
           if (method.isSetter) {
             memberHashMap["${name.name}="] = method;
           } else {
             memberHashMap[name.name] = method;
@@ skipping 221 matching lines @@
    * @param node the instance creation expression to evaluate
    * @param constructorName the constructor name, always non-`null`
    * @param typeName the name of the type defining the constructor, always non-`null`
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.CONST_DEFERRED_CLASS].
    */
   bool _checkForConstDeferredClass(InstanceCreationExpression node,
       ConstructorName constructorName, TypeName typeName) {
     if (typeName.isDeferred) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.CONST_DEFERRED_CLASS, constructorName, [
-        typeName.name.name
-      ]);
+          CompileTimeErrorCode.CONST_DEFERRED_CLASS, constructorName,
+          [typeName.name.name]);
       return true;
     }
     return false;
   }
 
   /**
    * This verifies that the passed throw expression is not enclosed in a 'const' constructor
    * declaration.
    *
    * @param node the throw expression expression to evaluate
@@ skipping 341 matching lines @@
    */
   bool _checkForExpectedOneListTypeArgument(
       ListLiteral node, TypeArgumentList typeArguments) {
     // check number of type arguments
     int num = typeArguments.arguments.length;
     if (num == 1) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        StaticTypeWarningCode.EXPECTED_ONE_LIST_TYPE_ARGUMENTS, typeArguments, [
-      num
-    ]);
+        StaticTypeWarningCode.EXPECTED_ONE_LIST_TYPE_ARGUMENTS, typeArguments,
+        [num]);
     return true;
   }
 
   /**
    * This verifies the passed import has unique name among other exported libraries.
    *
    * @param node the export directive to evaluate
    * @param exportElement the [ExportElement] retrieved from the node, if the element in the
    *          node was `null`, then this method is not called
    * @param exportedLibrary the library element containing the exported element
@@ skipping 324 matching lines @@
     if (_isInNativeClass) {
       return false;
     }
     bool foundError = false;
     if (!node.isSynthetic) {
       NodeList<VariableDeclaration> variables = node.variables;
       for (VariableDeclaration variable in variables) {
         if (variable.initializer == null) {
           if (node.isConst) {
             _errorReporter.reportErrorForNode(
-                CompileTimeErrorCode.CONST_NOT_INITIALIZED, variable.name, [
-              variable.name.name
-            ]);
+                CompileTimeErrorCode.CONST_NOT_INITIALIZED, variable.name,
+                [variable.name.name]);
           } else if (node.isFinal) {
             _errorReporter.reportErrorForNode(
-                StaticWarningCode.FINAL_NOT_INITIALIZED, variable.name, [
-              variable.name.name
-            ]);
+                StaticWarningCode.FINAL_NOT_INITIALIZED, variable.name,
+                [variable.name.name]);
           }
           foundError = true;
         }
       }
     }
     return foundError;
   }
 
   /**
    * This verifies that final fields that are declared, without any constructors in the enclosing
@@ skipping 300 matching lines @@
     // OK, top-level element
     if (executableElement.enclosingElement is! ClassElement) {
       return false;
     }
     // OK, instance member
     if (!executableElement.isStatic) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER, name, [
-      name.name
-    ]);
+        StaticTypeWarningCode.INSTANCE_ACCESS_TO_STATIC_MEMBER, name,
+        [name.name]);
     return true;
   }
 
   /**
    * This checks whether the given [executableElement] collides with the name of a static
    * method in one of its superclasses, and reports the appropriate warning if it does.
    *
    * @param executableElement the method to check.
    * @param errorNameTarget the node to report problems on.
    * @return `true` if and only if a warning was generated.
@@ skipping 175 matching lines @@
    * @param fieldName the field name from the [ConstructorFieldInitializer]
    * @param staticElement the static element from the name in the
    *          [ConstructorFieldInitializer]
    */
   void _checkForInvalidField(ConstructorFieldInitializer node,
       SimpleIdentifier fieldName, Element staticElement) {
     if (staticElement is FieldElement) {
       FieldElement fieldElement = staticElement;
       if (fieldElement.isSynthetic) {
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTENT_FIELD, node, [
-          fieldName
-        ]);
+            CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTENT_FIELD, node,
+            [fieldName]);
       } else if (fieldElement.isStatic) {
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.INITIALIZER_FOR_STATIC_FIELD, node, [
-          fieldName
-        ]);
+            CompileTimeErrorCode.INITIALIZER_FOR_STATIC_FIELD, node,
+            [fieldName]);
       }
     } else {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTENT_FIELD, node, [
-        fieldName
-      ]);
+          CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTENT_FIELD, node,
+          [fieldName]);
       return;
     }
   }
 
   /**
    * Check to see whether the given function body has a modifier associated with it, and report it
    * as an error if it does.
    *
    * @param body the function body being checked
    * @param errorCode the error code to be reported if a modifier is found
@@ skipping 304 matching lines @@
       if (constantName != null) {
         constantNames.remove(constantName);
       }
     }
     int nameCount = constantNames.length;
     if (nameCount == 0) {
       return false;
     }
     for (int i = 0; i < nameCount; i++) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.MISSING_ENUM_CONSTANT_IN_SWITCH, statement, [
-        constantNames[i]
-      ]);
+          CompileTimeErrorCode.MISSING_ENUM_CONSTANT_IN_SWITCH, statement,
+          [constantNames[i]]);
     }
     return true;
   }
 
   /**
    * This verifies that the given function body does not contain return statements that both have
    * and do not have return values.
    *
    * @param node the function body being tested
    * @return `true` if and only if an error code is generated on the passed node
@@ skipping 25 matching lines @@
    * @param mixinName the node to report problem on
    * @param mixinElement the mixing to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR].
    */
   bool _checkForMixinDeclaresConstructor(
       TypeName mixinName, ClassElement mixinElement) {
     for (ConstructorElement constructor in mixinElement.constructors) {
       if (!constructor.isSynthetic && !constructor.isFactory) {
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR, mixinName, [
-          mixinElement.name
-        ]);
+            CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR, mixinName,
+            [mixinElement.name]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed mixin has the 'Object' superclass.
    *
    * @param mixinName the node to report problem on
    * @param mixinElement the mixing to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT].
    */
   bool _checkForMixinInheritsNotFromObject(
       TypeName mixinName, ClassElement mixinElement) {
     InterfaceType mixinSupertype = mixinElement.supertype;
     if (mixinSupertype != null) {
       if (!mixinSupertype.isObject ||
           !mixinElement.isTypedef && mixinElement.mixins.length != 0) {
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT, mixinName, [
-          mixinElement.name
-        ]);
+            CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT, mixinName,
+            [mixinElement.name]);
         return true;
       }
     }
     return false;
   }
 
   /**
    * This verifies that the passed mixin does not reference 'super'.
    *
    * @param mixinName the node to report problem on
    * @param mixinElement the mixing to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.MIXIN_REFERENCES_SUPER].
    */
   bool _checkForMixinReferencesSuper(
       TypeName mixinName, ClassElement mixinElement) {
     if (mixinElement.hasReferenceToSuper) {
       _errorReporter.reportErrorForNode(
-          CompileTimeErrorCode.MIXIN_REFERENCES_SUPER, mixinName, [
-        mixinElement.name
-      ]);
+          CompileTimeErrorCode.MIXIN_REFERENCES_SUPER, mixinName,
+          [mixinElement.name]);
     }
     return false;
   }
 
   /**
    * This verifies that the passed constructor has at most one 'super' initializer.
    *
    * @param node the constructor declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
    * See [CompileTimeErrorCode.MULTIPLE_SUPER_INITIALIZERS].
@@ skipping 95 matching lines @@
     if (superType == null) {
       return false;
     }
     ClassElement superElement = superType.element;
     // try to find default generative super constructor
     ConstructorElement superUnnamedConstructor =
         superElement.unnamedConstructor;
     if (superUnnamedConstructor != null) {
       if (superUnnamedConstructor.isFactory) {
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR, node.name, [
-          superUnnamedConstructor
-        ]);
+            CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR, node.name,
+            [superUnnamedConstructor]);
         return true;
       }
       if (superUnnamedConstructor.isDefaultConstructor &&
           _enclosingClass
               .isSuperConstructorAccessible(superUnnamedConstructor)) {
         return true;
       }
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT, node.name, [
-      superType.displayName
-    ]);
+        CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT, node.name,
+        [superType.displayName]);
     return true;
   }
 
   /**
    * This checks that passed class declaration overrides all members required by its superclasses
    * and interfaces.
    *
    * @param classNameNode the [SimpleIdentifier] to be used if there is a violation, this is
    *          either the named from the [ClassDeclaration] or from the [ClassTypeAlias].
    * @return `true` if and only if an error code is generated on the passed node
@@ skipping 862 matching lines @@
     DartType bound = element.bound;
     if (bound == null) {
       return false;
     }
     // OK, type parameter is not supertype of its bound
     if (!bound.isMoreSpecificThan(element.type)) {
       return false;
     }
     // report problem
     _errorReporter.reportErrorForNode(
-        StaticTypeWarningCode.TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND, node, [
-      element.displayName
-    ]);
+        StaticTypeWarningCode.TYPE_PARAMETER_SUPERTYPE_OF_ITS_BOUND, node,
+        [element.displayName]);
     return true;
   }
 
   /**
    * This checks that if the passed generative constructor has neither an explicit super constructor
    * invocation nor a redirecting constructor invocation, that the superclass has a default
    * generative constructor.
    *
    * @param node the constructor declaration to evaluate
    * @return `true` if and only if an error code is generated on the passed node
@@ skipping 34 matching lines @@
     InterfaceType superType = _enclosingClass.supertype;
     if (superType == null) {
       return false;
     }
     ClassElement superElement = superType.element;
     ConstructorElement superUnnamedConstructor =
         superElement.unnamedConstructor;
     if (superUnnamedConstructor != null) {
       if (superUnnamedConstructor.isFactory) {
         _errorReporter.reportErrorForNode(
-            CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR, node.returnType, [
-          superUnnamedConstructor
-        ]);
+            CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR, node.returnType,
+            [superUnnamedConstructor]);
         return true;
       }
       if (!superUnnamedConstructor.isDefaultConstructor ||
           !_enclosingClass
               .isSuperConstructorAccessible(superUnnamedConstructor)) {
         int offset;
         int length;
         {
           Identifier returnType = node.returnType;
           SimpleIdentifier name = node.name;
@@ skipping 272 matching lines @@
     }
     if (!classElement.type.isSubtypeOf(_typeProvider.functionType)) {
       return false;
     }
     // If there is a noSuchMethod method, then don't report the warning,
     // see dartbug.com/16078
     if (classElement.getMethod(FunctionElement.NO_SUCH_METHOD_METHOD_NAME) !=
         null) {
       return false;
     }
-    ExecutableElement callMethod =
-        _inheritanceManager.lookupMember(classElement, "call");
+    ExecutableElement callMethod = _inheritanceManager.lookupMember(
+        classElement, FunctionElement.CALL_METHOD_NAME);
     if (callMethod == null ||
         callMethod is! MethodElement ||
         (callMethod as MethodElement).isAbstract) {
       _errorReporter.reportErrorForNode(
           StaticWarningCode.FUNCTION_WITHOUT_CALL, node.name);
       return true;
     }
     return false;
   }
 
@@ skipping 369 matching lines @@
             _enclosingClass.nameOffset, enclosingClassName.length, [
           enclosingClassName,
           buffer.toString()
         ]);
         return true;
       } else {
         // RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS or
         // RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS or
         // RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_WITH
         _errorReporter.reportErrorForOffset(_getBaseCaseErrorCode(classElt),
-            _enclosingClass.nameOffset, enclosingClassName.length, [
-          enclosingClassName
-        ]);
+            _enclosingClass.nameOffset, enclosingClassName.length,
+            [enclosingClassName]);
         return true;
       }
     }
     if (path.indexOf(classElt) > 0) {
       return false;
     }
     path.add(classElt);
     // n-case
     InterfaceType supertype = classElt.supertype;
     if (supertype != null &&
@@ skipping 89 matching lines @@
     toCheck.add(type.element);
     // type arguments
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
       for (DartType typeArgument in interfaceType.typeArguments) {
         _addTypeToCheck(typeArgument);
       }
     }
   }
 }