Do not generate warnings when noSuchMethod is inherited (issue 24337)

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:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/src/generated/static_type_analyzer.dart';
@@ skipping 2139 matching lines @@
       if (method.isGetter) {
         overriddenMember = _enclosingClass.lookUpInheritedConcreteGetter(
             memberName, _currentLibrary);
       } else if (method.isSetter) {
         overriddenMember = _enclosingClass.lookUpInheritedConcreteSetter(
             memberName, _currentLibrary);
       } else {
         overriddenMember = _enclosingClass.lookUpInheritedConcreteMethod(
             memberName, _currentLibrary);
       }
-      if (overriddenMember == null) {
+      if (overriddenMember == null && !_hasNoSuchMethod(_enclosingClass)) {
         _errorReporter.reportErrorForNode(
             StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER,
             nameNode,
             [memberName, _enclosingClass.displayName]);
         return true;
       }
     }
     return false;
   }
 
@@ skipping 2244 matching lines @@
    * See [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_ONE],
    * [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_TWO],
    * [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_THREE],
    * [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FOUR], and
    * [StaticWarningCode.NON_ABSTRACT_CLASS_INHERITS_ABSTRACT_MEMBER_FIVE_PLUS].
    */
   bool _checkForNonAbstractClassInheritsAbstractMember(
       SimpleIdentifier classNameNode) {
     if (_enclosingClass.isAbstract) {
       return false;
+    } else if (_hasNoSuchMethod(_enclosingClass)) {
+      return false;
     }
     //
     // Store in local sets the set of all method and accessor names
     //
-    MethodElement method =
-        _enclosingClass.getMethod(FunctionElement.NO_SUCH_METHOD_METHOD_NAME);
-    if (method != null) {
-      // If the enclosing class declares the method noSuchMethod(), then return.
-      // From Spec:  It is a static warning if a concrete class does not have an
-      // implementation for a method in any of its superinterfaces unless it
-      // declares its own noSuchMethod method (7.10).
-      return false;
-    }
     HashSet<ExecutableElement> missingOverrides =
         new HashSet<ExecutableElement>();
     //
     // Loop through the set of all executable elements declared in the implicit
     // interface.
     //
     MemberMap membersInheritedFromInterfaces = _inheritanceManager
         .getMapOfMembersInheritedFromInterfaces(_enclosingClass);
     MemberMap membersInheritedFromSuperclasses = _inheritanceManager
         .getMapOfMembersInheritedFromClasses(_enclosingClass);
@@ skipping 1141 matching lines @@
     ClassElement classElement = declaration.element;
     if (classElement == null) {
       return false;
     }
     if (!_typeSystem.isSubtypeOf(
         classElement.type, _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) {
+    if (_hasNoSuchMethod(classElement)) {
       return false;
     }
     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, declaration.name);
       return true;
@@ skipping 129 matching lines @@
           _errorReporter.reportErrorForToken(
               CompileTimeErrorCode.SHARED_DEFERRED_PREFIX, deferredToken);
           foundError = true;
         }
       }
     }
     return foundError;
   }
 
   /**
+   * Return `true` if the given [classElement] has a noSuchMethod() method
+   * distinct from the one declared in class Object, as per the Dart Language
+   * Specification (section 10.4).
+   */
+  bool _hasNoSuchMethod(ClassElement classElement) {
+    MethodElement method = classElement.lookUpMethod(
+        FunctionElement.NO_SUCH_METHOD_METHOD_NAME, classElement.library);
+    if (method == null) {
+      return false;
+    }
+    ClassElement definingClass =
+        method.getAncestor((Element element) => element is ClassElement);
+    return definingClass != null && !definingClass.type.isObject;
+  }
+
+  /**
    * Return `true` if the given [constructor] redirects to itself, directly or
    * indirectly.
    */
   bool _hasRedirectingFactoryConstructorCycle(ConstructorElement constructor) {
     Set<ConstructorElement> constructors = new HashSet<ConstructorElement>();
     ConstructorElement current = constructor;
     while (current != null) {
       if (constructors.contains(current)) {
         return identical(current, constructor);
       }
@@ skipping 303 matching lines @@
     toCheck.add(type.element);
     // type arguments
     if (type is InterfaceType) {
       InterfaceType interfaceType = type;
       for (DartType typeArgument in interfaceType.typeArguments) {
         _addTypeToCheck(typeArgument);
       }
     }
   }
 }