Issue 27300. Report HintCode.ABSTRACT_SUPER_MEMBER_REFERENCE.

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 265 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) {
+        _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 6854 matching lines @@
     DartType contextType = node.staticInvokeType;
     if (contextType is FunctionType) {
       DartType originalType = node.function.staticType;
       DartType returnContextType = InferenceContext.getContext(node);
       TypeSystem ts = typeSystem;
       if (returnContextType != null &&
           node.typeArguments == null &&
           originalType is FunctionType &&
           originalType.typeFormals.isNotEmpty &&
           ts is StrongTypeSystemImpl) {
-        contextType = ts.inferGenericFunctionCall(typeProvider, originalType,
-            DartType.EMPTY_LIST, DartType.EMPTY_LIST, originalType.returnType, returnContextType);
+        contextType = ts.inferGenericFunctionCall(
+            typeProvider,
+            originalType,
+            DartType.EMPTY_LIST,
+            DartType.EMPTY_LIST,
+            originalType.returnType,
+            returnContextType);
       }
 
       InferenceContext.setType(node.argumentList, contextType);
     }
   }
 
   void _inferFormalParameterList(FormalParameterList node, DartType type) {
     if (typeAnalyzer.inferFormalParameterList(node, type)) {
       // TODO(leafp): This gets dropped on the floor if we're in the field
       // inference task.  We should probably keep these infos.
@@ skipping 3894 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }