Issue 27300. Report HintCode.ABSTRACT_SUPER_MEMBER_REFERENCE. (Land again)

pkg/analyzer/lib/src/generated/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 analyzer.src.generated.resolver;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 34 matching lines @@
 //  static String _HASHCODE_GETTER_NAME = "hashCode";
 
   static String _NULL_TYPE_NAME = "Null";
 
   static String _TO_INT_METHOD_NAME = "toInt";
 
   /**
    * The class containing the AST nodes being visited, or `null` if we are not in the scope of
    * a class.
    */
-  ClassElement _enclosingClass;
+  ClassElementImpl _enclosingClass;
 
   /**
    * A flag indicating whether a surrounding member (compilation unit or class)
    * is deprecated.
    */
   bool inDeprecatedMember;
 
   /**
    * The error reporter by which errors will be reported.
    */
@@ skipping 14 matching lines @@
    * The type system primitives
    */
   TypeSystem _typeSystem;
 
   /**
    * The current library
    */
   LibraryElement _currentLibrary;
 
   /**
+   * The inheritance manager used to find overridden methods.
+   */
+  InheritanceManager _manager;
+
+  /**
    * Create a new instance of the [BestPracticesVerifier].
    *
    * @param errorReporter the error reporter
    */
-  BestPracticesVerifier(
-      this._errorReporter, TypeProvider typeProvider, this._currentLibrary,
+  BestPracticesVerifier(this._errorReporter, TypeProvider typeProvider,
+      this._currentLibrary, this._manager,
       {TypeSystem typeSystem})
       : _nullType = typeProvider.nullType,
         _futureNullType = typeProvider.futureNullType,
         _typeSystem = typeSystem ?? new TypeSystemImpl() {
     inDeprecatedMember = _currentLibrary.isDeprecated;
   }
 
   @override
   Object visitAnnotation(Annotation node) {
     if (node.elementAnnotation?.isFactory == true) {
@@ skipping 46 matching lines @@
 
   @override
   Object visitBinaryExpression(BinaryExpression node) {
     _checkForDivisionOptimizationHint(node);
     _checkForDeprecatedMemberUse(node.bestElement, node);
     return super.visitBinaryExpression(node);
   }
 
   @override
   Object visitClassDeclaration(ClassDeclaration node) {
-    ClassElement outerClass = _enclosingClass;
+    ClassElementImpl outerClass = _enclosingClass;
     bool wasInDeprecatedMember = inDeprecatedMember;
-    ClassElement element = node.element;
+    ClassElement element = AbstractClassElementImpl.getImpl(node.element);
     if (element != null && element.isDeprecated) {
       inDeprecatedMember = true;
     }
     try {
       _enclosingClass = element;
       // Commented out until we decide that we want this hint in the analyzer
       //    checkForOverrideEqualsButNotHashCode(node);
       return super.visitClassDeclaration(node);
     } finally {
       _enclosingClass = outerClass;
@@ skipping 101 matching lines @@
       _checkForMissingReturn(node.returnType, node.body);
       _checkForUnnecessaryNoSuchMethod(node);
       return super.visitMethodDeclaration(node);
     } finally {
       inDeprecatedMember = wasInDeprecatedMember;
     }
   }
 
   @override
   Object visitMethodInvocation(MethodInvocation node) {
+    Expression realTarget = node.realTarget;
+    _checkForAbstractSuperMemberReference(realTarget, node.methodName);
     _checkForCanBeNullAfterNullAware(
-        node.realTarget, node.operator, null, node.methodName);
+        realTarget, node.operator, null, node.methodName);
     DartType staticInvokeType = node.staticInvokeType;
     if (staticInvokeType is InterfaceType) {
       MethodElement methodElement = staticInvokeType.lookUpMethod(
           FunctionElement.CALL_METHOD_NAME, _currentLibrary);
       _checkForDeprecatedMemberUse(methodElement, node);
     }
     return super.visitMethodInvocation(node);
   }
 
   @override
   Object visitPostfixExpression(PostfixExpression node) {
     _checkForDeprecatedMemberUse(node.bestElement, node);
     return super.visitPostfixExpression(node);
   }
 
   @override
   Object visitPrefixExpression(PrefixExpression node) {
     _checkForDeprecatedMemberUse(node.bestElement, node);
     return super.visitPrefixExpression(node);
   }
 
   @override
   Object visitPropertyAccess(PropertyAccess node) {
+    Expression realTarget = node.realTarget;
+    _checkForAbstractSuperMemberReference(realTarget, node.propertyName);
     _checkForCanBeNullAfterNullAware(
-        node.realTarget, node.operator, node.propertyName, null);
+        realTarget, node.operator, node.propertyName, null);
     return super.visitPropertyAccess(node);
   }
 
   @override
   Object visitRedirectingConstructorInvocation(
       RedirectingConstructorInvocation node) {
     _checkForDeprecatedMemberUse(node.staticElement, node);
     return super.visitRedirectingConstructorInvocation(node);
   }
 
@@ skipping 79 matching lines @@
           // the is not case
           _errorReporter.reportErrorForNode(
               HintCode.TYPE_CHECK_IS_NOT_NULL, node);
         }
         return true;
       }
     }
     return false;
   }
 
+  void _checkForAbstractSuperMemberReference(
+      Expression target, SimpleIdentifier name) {
+    if (target is SuperExpression) {
+      Element element = name.staticElement;
+      if (element is ExecutableElement && element.isAbstract) {
+        if (!_enclosingClass.hasNoSuchMethod) {
+          ExecutableElement concrete = null;
+          if (element.kind == ElementKind.METHOD) {
+            concrete = _enclosingClass.lookUpInheritedConcreteMethod(
+                element.displayName, _currentLibrary);
+          } else if (element.kind == ElementKind.GETTER) {
+            concrete = _enclosingClass.lookUpInheritedConcreteGetter(
+                element.displayName, _currentLibrary);
+          } else if (element.kind == ElementKind.SETTER) {
+            concrete = _enclosingClass.lookUpInheritedConcreteSetter(
+                element.displayName, _currentLibrary);
+          }
+          if (concrete == null) {
+            _errorReporter.reportTypeErrorForNode(
+                HintCode.ABSTRACT_SUPER_MEMBER_REFERENCE,
+                name,
+                [element.kind.displayName, name.name]);
+          }
+        }
+      }
+    }
+  }
+
   /**
    * This verifies that the passed expression can be assigned to its corresponding parameters.
    *
    * This method corresponds to ErrorVerifier.checkForArgumentTypeNotAssignable.
    *
    * TODO (jwren) In the ErrorVerifier there are other warnings that we could have a corresponding
    * hint for: see other callers of ErrorVerifier.checkForArgumentTypeNotAssignable(..).
    *
    * @param expression the expression to evaluate
    * @param expectedStaticType the expected static type of the parameter
@@ skipping 3862 matching lines @@
     // dead code analysis
     unit.accept(
         new DeadCodeVerifier(errorReporter, typeSystem: _context.typeSystem));
     unit.accept(_usedLocalElementsVisitor);
     // dart2js analysis
     if (_enableDart2JSHints) {
       unit.accept(new Dart2JSVerifier(errorReporter));
     }
     // Dart best practices
     unit.accept(new BestPracticesVerifier(
-        errorReporter, _context.typeProvider, _library,
+        errorReporter, _context.typeProvider, _library, _manager,
         typeSystem: _context.typeSystem));
     unit.accept(new OverrideVerifier(errorReporter, _manager));
     // Find to-do comments
     new ToDoFinder(errorReporter).findIn(unit);
     // pub analysis
     // TODO(danrubel/jwren) Commented out until bugs in the pub verifier are
     // fixed
     //    unit.accept(new PubVerifier(context, errorReporter));
   }
 }
@@ skipping 6930 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }