Revert "Issue 27300. Report HintCode.ABSTRACT_SUPER_MEMBER_REFERENCE."

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 analyzer.src.generated.error_verifier;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 2638 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 && !_enclosingClass.hasNoSuchMethod) {
+      if (overriddenMember == null && !_hasNoSuchMethod(_enclosingClass)) {
         _errorReporter.reportErrorForNode(
             StaticWarningCode.CONCRETE_CLASS_WITH_ABSTRACT_MEMBER,
             nameNode,
             [memberName, _enclosingClass.displayName]);
       }
     }
   }
 
   /**
    * Verify all possible conflicts of the given [constructor]'s name with other
@@ skipping 2294 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].
    */
   void _checkForNonAbstractClassInheritsAbstractMember(
       SimpleIdentifier classNameNode) {
     if (_enclosingClass.isAbstract) {
       return;
-    } else if (_enclosingClass.hasNoSuchMethod) {
+    } else if (_hasNoSuchMethod(_enclosingClass)) {
       return;
     }
     //
     // Store in local sets the set of all method and accessor names
     //
     HashSet<ExecutableElement> missingOverrides =
         new HashSet<ExecutableElement>();
     //
     // Loop through the set of all executable elements declared in the implicit
     // interface.
@@ skipping 1106 matching lines @@
     ClassElement classElement = declaration.element;
     if (classElement == null) {
       return;
     }
     if (!_typeSystem.isSubtypeOf(
         classElement.type, _typeProvider.functionType)) {
       return;
     }
     // If there is a noSuchMethod method, then don't report the warning,
     // see dartbug.com/16078
-    if (_enclosingClass.hasNoSuchMethod) {
+    if (_hasNoSuchMethod(classElement)) {
       return;
     }
     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);
     }
@@ skipping 276 matching lines @@
     // Get the parameters for MethodDeclaration or FunctionDeclaration
     List<ParameterElement> setterParameters = setter.parameters;
     // If there are no setter parameters, return no type.
     if (setterParameters.length == 0) {
       return null;
     }
     return setterParameters[0].type;
   }
 
   /**
+   * 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) {
     ConstructorElement nonMember(ConstructorElement constructor) {
       return constructor is ConstructorMember
           ? constructor.baseElement
           : constructor;
     }
 
@@ skipping 487 matching lines @@
 class _InvocationCollector extends RecursiveAstVisitor {
   final List<String> superCalls = <String>[];
 
   @override
   visitMethodInvocation(MethodInvocation node) {
     if (node.target is SuperExpression) {
       superCalls.add(node.methodName.name);
     }
   }
 }