Move unused local variables and classes analysis into HintGenerator.

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 engine.resolver;
 
 import 'dart:collection';
 import "dart:math" as math;
 
 import 'java_core.dart';
@@ skipping 1891 matching lines @@
           _errorReporter.reportErrorForNode(HintCode.IS_NOT_DOUBLE, node);
         }
         return true;
       }
     }
     return false;
   }
 }
 
 /**
- * Instances of the class [UnusedElementVerifier] traverse an element
- * structure looking for cases of [HintCode.UNUSED_ELEMENT] and
- * [HintCode.UNUSED_LOCAL_VARIABLE].
- */
-class UnusedElementVerifier extends RecursiveElementVisitor {
-  /**
-   * The error reporter by which errors will be reported.
-   */
-  final ErrorReporter _errorReporter;
-
-  /**
-   * Create a new instance of the [UnusedElementVerifier].
-   */
-  UnusedElementVerifier(this._errorReporter);
-
-  @override
-  visitClassElement(ClassElement element) {
-    if (element is ClassElementImpl && !element.isUsed) {
-      _errorReporter.reportErrorForElement(
-          HintCode.UNUSED_ELEMENT,
-          element,
-          [element.kind.displayName, element.displayName]);
-    }
-    element.visitChildren(this);
-  }
-
-  @override
-  visitLocalVariableElement(LocalVariableElement element) {
-    if (element is LocalVariableElementImpl && !element.isUsed) {
-      _errorReporter.reportErrorForElement(
-          HintCode.UNUSED_LOCAL_VARIABLE,
-          element,
-          [element.displayName]);
-    }
-  }
-}
-
-/**
  * Instances of the class `DeadCodeVerifier` traverse an AST structure looking for cases of
  * [HintCode.DEAD_CODE].
  */
 class DeadCodeVerifier extends RecursiveAstVisitor<Object> {
   /**
    * The error reporter by which errors will be reported.
    */
   final ErrorReporter _errorReporter;
 
   /**
@@ skipping 1539 matching lines @@
   }
 
   @override
   Object visitCatchClause(CatchClause node) {
     SimpleIdentifier exceptionParameter = node.exceptionParameter;
     if (exceptionParameter != null) {
       // exception
       LocalVariableElementImpl exception = new LocalVariableElementImpl.forNode(exceptionParameter);
       _currentHolder.addLocalVariable(exception);
       exceptionParameter.staticElement = exception;
-      // we cannot catch an exception without declaring a variable,
-      // so the exception variable is always used
-      exception.markUsed();
       // stack trace
       SimpleIdentifier stackTraceParameter = node.stackTraceParameter;
       if (stackTraceParameter != null) {
         LocalVariableElementImpl stackTrace = new LocalVariableElementImpl.forNode(stackTraceParameter);
         _currentHolder.addLocalVariable(stackTrace);
         stackTraceParameter.staticElement = stackTrace;
       }
     }
     return super.visitCatchClause(node);
   }
@@ skipping 1848 matching lines @@
  *
  * See [HintCode].
  */
 class HintGenerator {
   final List<CompilationUnit> _compilationUnits;
 
   final AnalysisContext _context;
 
   final AnalysisErrorListener _errorListener;
 
+  LibraryElement _library;
+
   ImportsVerifier _importsVerifier;
 
   bool _enableDart2JSHints = false;
 
   /**
    * The inheritance manager used to find overridden methods.
    */
   InheritanceManager _manager;
 
+  _GatherUsedElementsVisitor _usedElementsVisitor;
+
   HintGenerator(this._compilationUnits, this._context, this._errorListener) {
-    LibraryElement library = _compilationUnits[0].element.library;
-    _importsVerifier = new ImportsVerifier(library);
+    _library = _compilationUnits[0].element.library;
+    _importsVerifier = new ImportsVerifier(_library);
     _enableDart2JSHints = _context.analysisOptions.dart2jsHint;
     _manager = new InheritanceManager(_compilationUnits[0].element.library);
+    _usedElementsVisitor = new _GatherUsedElementsVisitor(_library);
   }
 
   void generateForLibrary() {
     TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.hints.start();
     try {
       for (int i = 0; i < _compilationUnits.length; i++) {
         CompilationUnitElement element = _compilationUnits[i].element;
         if (element != null) {
           if (i == 0) {
             _importsVerifier.inDefiningCompilationUnit = true;
             _generateForCompilationUnit(_compilationUnits[i], element.source);
             _importsVerifier.inDefiningCompilationUnit = false;
           } else {
             _generateForCompilationUnit(_compilationUnits[i], element.source);
           }
         }
       }
       ErrorReporter definingCompilationUnitErrorReporter = new ErrorReporter(_errorListener, _compilationUnits[0].element.source);
       _importsVerifier.generateDuplicateImportHints(definingCompilationUnitErrorReporter);
       _importsVerifier.generateUnusedImportHints(definingCompilationUnitErrorReporter);
+      _library.accept(new _UnusedElementsVerifier(_errorListener, _usedElementsVisitor.usedElements));
     } finally {
       timeCounter.stop();
     }
   }
 
   void _generateForCompilationUnit(CompilationUnit unit, Source source) {
     ErrorReporter errorReporter = new ErrorReporter(_errorListener, source);
     unit.accept(_importsVerifier);
     // dead code analysis
     unit.accept(new DeadCodeVerifier(errorReporter));
-    unit.element.accept(new UnusedElementVerifier(errorReporter));
+    unit.accept(_usedElementsVisitor);
     // dart2js analysis
     if (_enableDart2JSHints) {
       unit.accept(new Dart2JSVerifier(errorReporter));
     }
     // Dart best practices
     unit.accept(new BestPracticesVerifier(errorReporter));
     unit.accept(new OverrideVerifier(_manager, errorReporter));
     // Find to-do comments
     new ToDoFinder(errorReporter).findIn(unit);
     // pub analysis
@@ skipping 9704 matching lines @@
         types.add(type);
       }
     }
     return types;
   }
 
   void _setElement(Identifier typeName, Element element) {
     if (element != null) {
       if (typeName is SimpleIdentifier) {
         typeName.staticElement = element;
-        _markTypeNameElementUsed(typeName, element);
       } else if (typeName is PrefixedIdentifier) {
         PrefixedIdentifier identifier = typeName;
         identifier.identifier.staticElement = element;
         SimpleIdentifier prefix = identifier.prefix;
         Element prefixElement = nameScope.lookup(prefix, definingLibrary);
         if (prefixElement != null) {
           prefix.staticElement = prefixElement;
         }
       }
     }
   }
 
   /**
-   * Marks [element] as used in its defining library.
-   */
-  void _markTypeNameElementUsed(Identifier typeName, Element element) {
-    if (identical(element, _enclosingClass)) {
-      return;
-    }
-    // ignore places where the element is not actually used
-    if (typeName.parent is TypeName) {
-      AstNode parent2 = typeName.parent.parent;
-      if (parent2 is IsExpression) {
-        return;
-      }
-      if (parent2 is VariableDeclarationList) {
-        return;
-      }
-    }
-    // check if the element is a local top-level element
-    if (element is ElementImpl &&
-        element.enclosingElement is CompilationUnitElement &&
-        identical(element.library, definingLibrary)) {
-      element.markUsed();
-    }
-  }
-
-  /**
    * Given a parameter element, create a function type based on the given return type and parameter
    * list and associate the created type with the element.
    *
    * @param element the parameter element whose type is to be set
    * @param returnType the (possibly `null`) return type of the function
    * @param parameterList the list of parameters to the function
    */
   void _setFunctionTypedParameterType(ParameterElementImpl element, TypeName returnType, FormalParameterList parameterList) {
     List<ParameterElement> parameters = _getElements(parameterList);
     FunctionTypeAliasElementImpl aliasElement = new FunctionTypeAliasElementImpl.forNode(null);
@@ skipping 187 matching lines @@
     ElementKind kind = element.kind;
     if (kind == ElementKind.LOCAL_VARIABLE) {
       node.staticElement = element;
       LocalVariableElementImpl variableImpl = element as LocalVariableElementImpl;
       if (node.inSetterContext()) {
         variableImpl.markPotentiallyMutatedInScope();
         if (element.enclosingElement != _enclosingFunction) {
           variableImpl.markPotentiallyMutatedInClosure();
         }
       }
-      if (node.inGetterContext()) {
-        if (parent.parent is ExpressionStatement &&
-            (parent is PrefixExpression ||
-             parent is PostfixExpression ||
-             parent is AssignmentExpression && parent.leftHandSide == node)) {
-          // v++;
-          // ++v;
-          // v += 2;
-        } else {
-          variableImpl.markUsed();
-        }
-      }
-      if (parent is MethodInvocation && parent.methodName == node) {
-        variableImpl.markUsed();
-      }
     } else if (kind == ElementKind.PARAMETER) {
       node.staticElement = element;
       if (node.inSetterContext()) {
         ParameterElementImpl parameterImpl = element as ParameterElementImpl;
         parameterImpl.markPotentiallyMutatedInScope();
         // If we are in some closure, check if it is not the same as where variable is declared.
         if (_enclosingFunction != null && (element.enclosingElement != _enclosingFunction)) {
           parameterImpl.markPotentiallyMutatedInClosure();
         }
       }
@@ skipping 189 matching lines @@
   /**
    * Return the tag that has the given identifier, or {@code null} if there is no such tag (the
    * identifier is not defined).
    *
    * @return the tag that has the given identifier
    */
   String getTagWithId(String identifier) {
     return idToTagMap[identifier];
   }
 }
+
+
+class _GatherUsedElementsVisitor extends RecursiveAstVisitor {
+  final Set<Element> usedElements = new HashSet<Element>();
+
+  final LibraryElement _enclosingLibrary;
+  ClassElement _enclosingClass;
+
+  _GatherUsedElementsVisitor(this._enclosingLibrary);
+
+  @override
+  visitCatchClause(CatchClause node) {
+    SimpleIdentifier exceptionParameter = node.exceptionParameter;
+    _useStaticElement(exceptionParameter);
+    super.visitCatchClause(node);
+  }
+
+  @override
+  visitClassDeclaration(ClassDeclaration node) {
+    ClassElement enclosingClassOld = _enclosingClass;
+    try {
+      _enclosingClass = node.element;
+      super.visitClassDeclaration(node);
+    } finally {
+      _enclosingClass = enclosingClassOld;
+    }
+  }
+
+  @override
+  visitSimpleIdentifier(SimpleIdentifier node) {
+    if (node.inDeclarationContext()) {
+      return;
+    }
+    Element staticElement = node.staticElement;
+    if (staticElement is LocalVariableElement) {
+      AstNode parent = node.parent;
+      if (node.inGetterContext()) {
+        if (parent.parent is ExpressionStatement &&
+            (parent is PrefixExpression ||
+             parent is PostfixExpression ||
+             parent is AssignmentExpression && parent.leftHandSide == node)) {
+          // v++;
+          // ++v;
+          // v += 2;
+        } else {
+          _useElement(staticElement);
+        }
+      }
+      if (parent is MethodInvocation && parent.methodName == node) {
+        _useElement(staticElement);
+      }
+    } else {
+      _useIdentifierElement(node);
+    }
+  }
+
+  @override
+  visitTypeName(TypeName node) {
+    _useIdentifierElement(node.name);
+  }
+
+  /**
+   * Marks an [Element] of [node] as used in the library.
+   */
+  void _useIdentifierElement(Identifier node) {
+    Element element = node.staticElement;
+    if (element == null) {
+      return;
+    }
+    // check if a local element
+    if (!identical(element.library, _enclosingLibrary)) {
+      return;
+    }
+    // ignore references to an element from itself
+    if (identical(element, _enclosingClass)) {
+      return;
+    }
+    // ignore places where the element is not actually used
+    if (node.parent is TypeName) {
+      AstNode parent2 = node.parent.parent;
+      if (parent2 is IsExpression) {
+        return;
+      }
+      if (parent2 is VariableDeclarationList) {
+        return;
+      }
+    }
+    // OK
+    _useElement(element);
+  }
+
+  _useElement(Element element) {
+    if (element != null) {
+      usedElements.add(element);
+    }
+  }
+
+  void _useStaticElement(SimpleIdentifier identifier) {
+    if (identifier != null) {
+      _useElement(identifier.staticElement);
+    }
+  }
+}
+
+
+/**
+ * Instances of the class [_UnusedElementsVerifier] traverse an element
+ * structure looking for cases of [HintCode.UNUSED_ELEMENT] and
+ * [HintCode.UNUSED_LOCAL_VARIABLE].
+ */
+class _UnusedElementsVerifier extends RecursiveElementVisitor {
+  /**
+   * The error listener to which errors will be reported.
+   */
+  final AnalysisErrorListener _errorListener;
+
+  /**
+   * The elements know to be used.
+   */
+  final Set<Element> _usedElements;
+
+  /**
+   * Create a new instance of the [_UnusedElementsVerifier].
+   */
+  _UnusedElementsVerifier(this._errorListener, this._usedElements);
+
+  @override
+  visitClassElement(ClassElement element) {
+    if (!_isUsed(element)) {
+      _reportErrorForElement(
+          HintCode.UNUSED_ELEMENT,
+          element,
+          [element.kind.displayName, element.displayName]);
+    }
+    element.visitChildren(this);
+  }
+
+  @override
+  visitLocalVariableElement(LocalVariableElement element) {
+    if (!_isUsed(element)) {
+      _reportErrorForElement(
+          HintCode.UNUSED_LOCAL_VARIABLE,
+          element,
+          [element.displayName]);
+    }
+  }
+
+  bool _isUsed(Element element) {
+    if (element is! LocalVariableElement) {
+      if (element.isPublic) {
+        return true;
+      }
+    }
+    return _usedElements.contains(element);
+  }
+
+  void _reportErrorForElement(ErrorCode errorCode, Element element, List<Object> arguments) {
+    if (element != null) {
+      _errorListener.onError(
+          new AnalysisError.con2(
+              element.source,
+              element.nameOffset,
+              element.displayName.length,
+              errorCode,
+              arguments));
+    }
+  }
+}