Validation of @protected property accesses.

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 220 matching lines @@
   @override
   Object visitRedirectingConstructorInvocation(
       RedirectingConstructorInvocation node) {
     _checkForDeprecatedMemberUse(node.staticElement, node);
     return super.visitRedirectingConstructorInvocation(node);
   }
 
   @override
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     _checkForDeprecatedMemberUseAtIdentifier(node);
+    _checkForInvalidProtectedPropertyAccess(node);
     return super.visitSimpleIdentifier(node);
   }
 
   @override
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     _checkForDeprecatedMemberUse(node.staticElement, node);
     return super.visitSuperConstructorInvocation(node);
   }
 
   @override
@@ skipping 351 matching lines @@
       if (!_typeSystem.isAssignableTo(bestRightType, leftType)) {
         _errorReporter.reportTypeErrorForNode(
             HintCode.INVALID_ASSIGNMENT, rhs, [bestRightType, leftType]);
         return true;
       }
     }
     return false;
   }
 
   /**
+   * 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 != null) {

[Brian Wilkerson, 2016/02/24 19:54:25]

The 'is' test below should negate the need to the null check.

[pquitslund, 2016/02/24 20:34:43]

Nice.  I missed that when I refactored.  Thanks!

+      if (element is PropertyAccessorElement &&
+          (element.isProtected || element.variable.isProtected)) {
+        ClassElement definingClass = element.enclosingElement;
+        if (definingClass == null) {
+          return;
+        }
+        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)) {
+          _errorReporter.reportErrorForNode(
+              HintCode.INVALID_USE_OF_PROTECTED_MEMBER,
+              identifier,
+              [identifier.name.toString(), definingClass.name]);
+        }
+      }
+    }
+  }
+
+  /**
    * Produces a hint if the given invocation is of a protected method outside
    * a subclass instance method.
    */
   void _checkForInvalidProtectedMethodCalls(MethodInvocation node) {
     Element element = node.methodName.bestElement;
     if (element == null || !element.isProtected) {
       return;
     }
 
     ClassElement definingClass = element.enclosingElement;
@@ skipping 12324 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }