Rename UsedElements -> UsedLocalElements.

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:math" as math;
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/utilities_collection.dart';
@@ skipping 4332 matching lines @@
    */
   void _defineTypeParameters() {
     Scope typeParameterScope = enclosingScope;
     for (TypeParameterElement typeParameter in _typeElement.typeParameters) {
       typeParameterScope.define(typeParameter);
     }
   }
 }
 
 /**
- * An [AstVisitor] that fills [UsedElements].
+ * An [AstVisitor] that fills [UsedLocalElements].
  */
-class GatherUsedElementsVisitor extends RecursiveAstVisitor {
-  final UsedElements usedElements = new UsedElements();
+class GatherUsedLocalElementsVisitor extends RecursiveAstVisitor {
+  final UsedLocalElements usedElements = new UsedLocalElements();
 
   final LibraryElement _enclosingLibrary;
   ClassElement _enclosingClass;
   ExecutableElement _enclosingExec;
 
-  GatherUsedElementsVisitor(this._enclosingLibrary);
+  GatherUsedLocalElementsVisitor(this._enclosingLibrary);
 
   @override
   visitCatchClause(CatchClause node) {
     SimpleIdentifier exceptionParameter = node.exceptionParameter;
     SimpleIdentifier stackTraceParameter = node.stackTraceParameter;
     if (exceptionParameter != null) {
       Element element = exceptionParameter.staticElement;
       usedElements.addCatchException(element);
       if (stackTraceParameter != null || node.onKeyword == null) {
         usedElements.addElement(element);
@@ skipping 146 matching lines @@
 
   ImportsVerifier _importsVerifier;
 
   bool _enableDart2JSHints = false;
 
   /**
    * The inheritance manager used to find overridden methods.
    */
   InheritanceManager _manager;
 
-  GatherUsedElementsVisitor _usedElementsVisitor;
+  GatherUsedLocalElementsVisitor _usedElementsVisitor;
 
   HintGenerator(this._compilationUnits, this._context, this._errorListener) {
     _library = _compilationUnits[0].element.library;
     _importsVerifier = new ImportsVerifier(_library);
     _enableDart2JSHints = _context.analysisOptions.dart2jsHint;
     _manager = new InheritanceManager(_compilationUnits[0].element.library);
-    _usedElementsVisitor = new GatherUsedElementsVisitor(_library);
+    _usedElementsVisitor = new GatherUsedLocalElementsVisitor(_library);
   }
 
   void generateForLibrary() {
     PerformanceStatistics.hints.makeCurrentWhile(() {
       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(
+      _library.accept(new UnusedLocalElementsVerifier(
           _errorListener, _usedElementsVisitor.usedElements));
     });
   }
 
   void _generateForCompilationUnit(CompilationUnit unit, Source source) {
     ErrorReporter errorReporter = new ErrorReporter(_errorListener, source);
     unit.accept(_importsVerifier);
     // dead code analysis
     unit.accept(new DeadCodeVerifier(errorReporter));
     unit.accept(_usedElementsVisitor);
@@ skipping 10373 matching lines @@
       return identical(parent.type, node);
     }
     if (parent is SimpleFormalParameter) {
       return identical(parent.type, node);
     }
     return false;
   }
 }
 
 /**
- * Instances of the class [UnusedElementsVerifier] traverse an element
- * structure looking for cases of [HintCode.UNUSED_ELEMENT] and
- * [HintCode.UNUSED_LOCAL_VARIABLE].
+ * Instances of the class [UnusedLocalElementsVerifier] traverse an element
+ * structure looking for cases of [HintCode.UNUSED_ELEMENT],
+ * [HintCode.UNUSED_FIELD], [HintCode.UNUSED_LOCAL_VARIABLE], etc.
  */
-class UnusedElementsVerifier extends RecursiveElementVisitor {
+class UnusedLocalElementsVerifier extends RecursiveElementVisitor {
   /**
    * The error listener to which errors will be reported.
    */
   final AnalysisErrorListener _errorListener;
 
   /**
    * The elements know to be used.
    */
-  final UsedElements _usedElements;
+  final UsedLocalElements _usedElements;
 
   /**
-   * Create a new instance of the [UnusedElementsVerifier].
+   * Create a new instance of the [UnusedLocalElementsVerifier].
    */
-  UnusedElementsVerifier(this._errorListener, this._usedElements);
+  UnusedLocalElementsVerifier(this._errorListener, this._usedElements);
 
   @override
   visitClassElement(ClassElement element) {
     if (!_isUsedElement(element)) {
       _reportErrorForElement(HintCode.UNUSED_ELEMENT, element, [
         element.kind.displayName,
         element.displayName
       ]);
     }
     super.visitClassElement(element);
@@ skipping 113 matching lines @@
     if (element != null) {
       _errorListener.onError(new AnalysisError.con2(element.source,
           element.nameOffset, element.displayName.length, errorCode,
           arguments));
     }
   }
 }
 
 /**
  * A container with sets of used [Element]s.
+ * All these elements are defined in a single compilation unit or a library.
  */
-class UsedElements {
+class UsedLocalElements {
   /**
    * Resolved, locally defined elements that are used or potentially can be
    * used.
    */
   final HashSet<Element> elements = new HashSet<Element>();
 
   /**
    * [LocalVariableElement]s that represent exceptions in [CatchClause]s.
    */
   final HashSet<LocalVariableElement> catchExceptionElements =
@@ skipping 10 matching lines @@
    * library.
    */
   final HashSet<String> members = new HashSet<String>();
 
   /**
    * Names of resolved or unresolved class members that are read in the
    * library.
    */
   final HashSet<String> readMembers = new HashSet<String>();
 
-  UsedElements();
+  UsedLocalElements();
 
-  factory UsedElements.merge(List<UsedElements> parts) {
-    UsedElements result = new UsedElements();
-    for (UsedElements part in parts) {
+  factory UsedLocalElements.merge(List<UsedLocalElements> parts) {
+    UsedLocalElements result = new UsedLocalElements();
+    for (UsedLocalElements part in parts) {
       result.elements.addAll(part.elements);
       result.catchExceptionElements.addAll(part.catchExceptionElements);
       result.catchStackTraceElements.addAll(part.catchStackTraceElements);
       result.members.addAll(part.members);
       result.readMembers.addAll(part.readMembers);
     }
     return result;
   }
 
   void addCatchException(LocalVariableElement element) {
@@ skipping 331 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }