Stop reporting use of deprecated members from within deprecated members (issue 25966)

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 55 matching lines @@
 
   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;
 
   /**
+   * A flag indicating whether a surrounding member (compilation unit or class)
+   * is deprecated.
+   */
+  bool inDeprecatedMember = false;
+
+  /**
    * The error reporter by which errors will be reported.
    */
   final ErrorReporter _errorReporter;
 
   /**
    * The type Future<Null>, which is needed for determining whether it is safe
    * to have a bare "return;" in an async method.
    */
   final InterfaceType _futureNullType;
 
@@ skipping 45 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;
+    bool wasInDeprecatedMember = inDeprecatedMember;
+    ClassElement element = node.element;
+    if (element != null && element.isDeprecated) {
+      inDeprecatedMember = true;

[scheglov, 2016/03/13 20:41:23]

This could be a single assignment statement.

+    }
     try {
-      _enclosingClass = node.element;
+      _enclosingClass = element;
       // Commented out until we decide that we want this hint in the analyzer
       //    checkForOverrideEqualsButNotHashCode(node);
       return super.visitClassDeclaration(node);
     } finally {
       _enclosingClass = outerClass;
+      inDeprecatedMember = wasInDeprecatedMember;
     }
   }
 
   @override
   Object visitConditionalExpression(ConditionalExpression node) {
     _checkForPossibleNullCondition(node.condition);
     return super.visitConditionalExpression(node);
   }
 
   @override
   Object visitDoStatement(DoStatement node) {
     _checkForPossibleNullCondition(node.condition);
     return super.visitDoStatement(node);
   }
 
   @override
   Object visitExportDirective(ExportDirective node) {
     _checkForDeprecatedMemberUse(node.uriElement, node);
     return super.visitExportDirective(node);
   }
 
   @override
   Object visitForStatement(ForStatement node) {
     _checkForPossibleNullCondition(node.condition);
     return super.visitForStatement(node);
   }
 
   @override
   Object visitFunctionDeclaration(FunctionDeclaration node) {
-    _checkForMissingReturn(node.returnType, node.functionExpression.body);
-    return super.visitFunctionDeclaration(node);
+    bool wasInDeprecatedMember = inDeprecatedMember;
+    ExecutableElement element = node.element;
+    if (element != null && element.isDeprecated) {
+      inDeprecatedMember = true;
+    }
+    try {
+      _checkForMissingReturn(node.returnType, node.functionExpression.body);
+      return super.visitFunctionDeclaration(node);
+    } finally {
+      inDeprecatedMember = wasInDeprecatedMember;
+    }
   }
 
   @override
   Object visitIfStatement(IfStatement node) {
     _checkForPossibleNullCondition(node.condition);
     return super.visitIfStatement(node);
   }
 
   @override
   Object visitImportDirective(ImportDirective node) {
@@ skipping 20 matching lines @@
   }
 
   @override
   Object visitIsExpression(IsExpression node) {
     _checkAllTypeChecks(node);
     return super.visitIsExpression(node);
   }
 
   @override
   Object visitMethodDeclaration(MethodDeclaration node) {
-    // This was determined to not be a good hint, see: dartbug.com/16029
-    //checkForOverridingPrivateMember(node);
-    _checkForMissingReturn(node.returnType, node.body);
-    _checkForUnnecessaryNoSuchMethod(node);
-    return super.visitMethodDeclaration(node);
+    bool wasInDeprecatedMember = inDeprecatedMember;
+    ExecutableElement element = node.element;
+    if (element != null && element.isDeprecated) {
+      inDeprecatedMember = true;
+    }
+    try {
+      // This was determined to not be a good hint, see: dartbug.com/16029
+      //checkForOverridingPrivateMember(node);
+      _checkForMissingReturn(node.returnType, node.body);
+      _checkForUnnecessaryNoSuchMethod(node);
+      return super.visitMethodDeclaration(node);
+    } finally {
+      inDeprecatedMember = wasInDeprecatedMember;
+    }
   }
 
   @override
   Object visitMethodInvocation(MethodInvocation node) {
     _checkForCanBeNullAfterNullAware(node.realTarget, node.operator);
     _checkForInvalidProtectedMethodCalls(node);
     return super.visitMethodInvocation(node);
   }
 
   @override
@@ skipping 263 matching lines @@
 
   /**
    * Given some [Element], look at the associated metadata and report the use of the member if
    * it is declared as deprecated.
    *
    * @param element some element to check for deprecated use of
    * @param node the node use for the location of the error
    * @return `true` if and only if a hint code is generated on the passed node
    * See [HintCode.DEPRECATED_MEMBER_USE].
    */
-  bool _checkForDeprecatedMemberUse(Element element, AstNode node) {
-    if (element != null && element.isDeprecated) {
+  void _checkForDeprecatedMemberUse(Element element, AstNode node) {
+    if (element != null && element.isDeprecated && !inDeprecatedMember) {
       String displayName = element.displayName;
       if (element is ConstructorElement) {
         // TODO(jwren) We should modify ConstructorElement.getDisplayName(),
         // or have the logic centralized elsewhere, instead of doing this logic
         // here.
         ConstructorElement constructorElement = element;
         displayName = constructorElement.enclosingElement.displayName;
         if (!constructorElement.displayName.isEmpty) {
           displayName = "$displayName.${constructorElement.displayName}";
         }
       }
       _errorReporter.reportErrorForNode(
           HintCode.DEPRECATED_MEMBER_USE, node, [displayName]);
-      return true;
     }
-    return false;
   }
 
   /**
    * For [SimpleIdentifier]s, only call [checkForDeprecatedMemberUse]
    * if the node is not in a declaration context.
    *
    * Also, if the identifier is a constructor name in a constructor invocation, then calls to the
    * deprecated constructor will be caught by
    * [visitInstanceCreationExpression] and
    * [visitSuperConstructorInvocation], and can be ignored by
    * this visit method.
    *
    * @param identifier some simple identifier to check for deprecated use of
    * @return `true` if and only if a hint code is generated on the passed node
    * See [HintCode.DEPRECATED_MEMBER_USE].
    */
-  bool _checkForDeprecatedMemberUseAtIdentifier(SimpleIdentifier identifier) {
+  void _checkForDeprecatedMemberUseAtIdentifier(SimpleIdentifier identifier) {
     if (identifier.inDeclarationContext()) {
-      return false;
+      return;
     }
     AstNode parent = identifier.parent;
     if ((parent is ConstructorName && identical(identifier, parent.name)) ||
         (parent is ConstructorDeclaration &&
             identical(identifier, parent.returnType)) ||
         (parent is SuperConstructorInvocation &&
             identical(identifier, parent.constructorName)) ||
         parent is HideCombinator) {
-      return false;
+      return;
     }
-    return _checkForDeprecatedMemberUse(identifier.bestElement, identifier);
+    _checkForDeprecatedMemberUse(identifier.bestElement, identifier);
   }
 
   /**
    * Check for the passed binary expression for the [HintCode.DIVISION_OPTIMIZATION].
    *
    * @param node the binary expression to check
    * @return `true` if and only if a hint code is generated on the passed node
    * See [HintCode.DIVISION_OPTIMIZATION].
    */
   bool _checkForDivisionOptimizationHint(BinaryExpression node) {
@@ skipping 12369 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }