Extend @protected to include implemented interfaces.

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 682 matching lines @@
         node.getAncestor((AstNode node) => node is MethodDeclaration);
     if (decl == null) {
       _errorReporter.reportErrorForNode(
           HintCode.INVALID_USE_OF_PROTECTED_MEMBER,
           node,
           [node.methodName.toString(), definingClass.name]);
       return;
     }
 
     ClassElement invokingClass = decl.element?.enclosingElement;
-    if (invokingClass != null) {
-      if (!_hasSuperClassOrMixin(invokingClass, definingClass.type)) {
-        _errorReporter.reportErrorForNode(
-            HintCode.INVALID_USE_OF_PROTECTED_MEMBER,
-            node,
-            [node.methodName.toString(), definingClass.name]);
-      }
+    if (!_hasSuperType(invokingClass, definingClass.type)) {
+      _errorReporter.reportErrorForNode(
+          HintCode.INVALID_USE_OF_PROTECTED_MEMBER,
+          node,
+          [node.methodName.toString(), definingClass.name]);
     }
   }
 
   /**
    * Produces a hint if the given identifier is a protected field or getter
    * accessed outside a subclass.
    */
   void _checkForInvalidProtectedPropertyAccess(SimpleIdentifier identifier) {
     if (identifier.inDeclarationContext()) {
       return;
     }
     Element element = identifier.bestElement;
     if (element is PropertyAccessorElement &&
         element.enclosingElement is ClassElement &&
         (element.isProtected || element.variable.isProtected)) {
       ClassElement definingClass = element.enclosingElement;
       ClassDeclaration accessingClass =
           identifier.getAncestor((AstNode node) => node is ClassDeclaration);
 
       if (accessingClass == null) {
         _errorReporter.reportErrorForNode(
             HintCode.INVALID_USE_OF_PROTECTED_MEMBER,
             identifier,
             [identifier.name.toString(), definingClass.name]);
-      } else if (!_hasSuperClassOrMixin(
-          accessingClass.element, definingClass.type)) {
+      } else if (!_hasSuperType(accessingClass.element, definingClass.type)) {
         _errorReporter.reportErrorForNode(
             HintCode.INVALID_USE_OF_PROTECTED_MEMBER,
             identifier,
             [identifier.name.toString(), definingClass.name]);
       }
     }
   }
 
   /**
    * Check that the imported library does not define a loadLibrary function. The import has already
@@ skipping 209 matching lines @@
           _errorReporter.reportErrorForNode(
               HintCode.UNNECESSARY_NO_SUCH_METHOD, node);
           return true;
         }
       }
     }
     return false;
   }
 
   /**
+   * Check for situations where the result of a method or function is used, when
+   * it returns 'void'.
+   *
+   * See [HintCode.USE_OF_VOID_RESULT].
+   */
+  void _checkForUseOfVoidResult(Expression expression) {
+    // TODO(jwren) Many other situations of use could be covered. We currently
+    // cover the cases var x = m() and x = m(), but we could also cover cases
+    // such as m().x, m()[k], a + m(), f(m()), return m().
+    if (expression is MethodInvocation) {
+      if (identical(expression.staticType, VoidTypeImpl.instance)) {
+        SimpleIdentifier methodName = expression.methodName;
+        _errorReporter.reportErrorForNode(
+            HintCode.USE_OF_VOID_RESULT, methodName, [methodName.name]);
+      }
+    }
+  }
+
+  /**
    * Check for the passed class declaration for the
    * [HintCode.OVERRIDE_EQUALS_BUT_NOT_HASH_CODE] hint code.
    *
    * @param node the class declaration to check
    * @return `true` if and only if a hint code is generated on the passed node
    * See [HintCode.OVERRIDE_EQUALS_BUT_NOT_HASH_CODE].
    */
 //  bool _checkForOverrideEqualsButNotHashCode(ClassDeclaration node) {
 //    ClassElement classElement = node.element;
 //    if (classElement == null) {
 //      return false;
 //    }
 //    MethodElement equalsOperatorMethodElement =
 //        classElement.getMethod(sc.TokenType.EQ_EQ.lexeme);
 //    if (equalsOperatorMethodElement != null) {
 //      PropertyAccessorElement hashCodeElement =
 //          classElement.getGetter(_HASHCODE_GETTER_NAME);
 //      if (hashCodeElement == null) {
 //        _errorReporter.reportErrorForNode(
 //            HintCode.OVERRIDE_EQUALS_BUT_NOT_HASH_CODE,
 //            node.name,
 //            [classElement.displayName]);
 //        return true;
 //      }
 //    }
 //    return false;
 //  }
 
-  /**
-   * Check for situations where the result of a method or function is used, when
-   * it returns 'void'.
-   *
-   * See [HintCode.USE_OF_VOID_RESULT].
-   */
-  void _checkForUseOfVoidResult(Expression expression) {
-    // TODO(jwren) Many other situations of use could be covered. We currently
-    // cover the cases var x = m() and x = m(), but we could also cover cases
-    // such as m().x, m()[k], a + m(), f(m()), return m().
-    if (expression is MethodInvocation) {
-      if (identical(expression.staticType, VoidTypeImpl.instance)) {
-        SimpleIdentifier methodName = expression.methodName;
-        _errorReporter.reportErrorForNode(
-            HintCode.USE_OF_VOID_RESULT, methodName, [methodName.name]);
-      }
-    }
-  }
-
   bool _hasSuperClassOrMixin(ClassElement element, InterfaceType type) {
     List<ClassElement> seenClasses = <ClassElement>[];
     while (element != null && !seenClasses.contains(element)) {
       if (element.type == type) {
         return true;
       }
 
       if (element.mixins.any((InterfaceType t) => t == type)) {
         return true;
       }
 
       seenClasses.add(element);
       element = element.supertype?.element;
     }
 
     return false;
   }
 
+  bool _hasSuperType(ClassElement element, InterfaceType type) =>
+      element != null && element.allSupertypes.contains(type);
+
   /**
    * Given a parenthesized expression, this returns the parent (or recursively grand-parent) of the
    * expression that is a parenthesized expression, but whose parent is not a parenthesized
    * expression.
    *
    * For example given the code `(((e)))`: `(e) -> (((e)))`.
    *
    * @param parenthesizedExpression some expression whose parent is a parenthesized expression
    * @return the first parent or grand-parent that is a parenthesized expression, that does not have
    *         a parenthesized expression parent
@@ skipping 9938 matching lines @@
       return null;
     }
     if (identical(node.staticElement, variable)) {
       if (node.inSetterContext()) {
         result = true;
       }
     }
     return null;
   }
 }