anchor.diff:   * While this class does not yet have support for an "Organize Imports" action, this logic built up
    * in this class could be used for such an action in the future.
    */
  -class ImportsVerifier extends RecursiveAstVisitor<Object> {
  -  /**
  -   * This is set to `true` if the current compilation unit which is being visited is the
  -   * defining compilation unit for the library, its value can be set with
  -   * [setInDefiningCompilationUnit].
  -   */
  -  bool _inDefiningCompilationUnit = false;
  -
  -  /**
  -   * The current library.
  -   */
  -  LibraryElement _currentLibrary;
  -
  +class ImportsVerifier /*extends RecursiveAstVisitor<Object>*/ {
     /**
      * A list of [ImportDirective]s that the current library imports, as identifiers are visited
      * by this visitor and an import has been identified as being used by the library, the
  
positive.code:    *
     * See [ImportsVerifier.generateUnusedImportErrors].
     */
    List<ImportDirective> _unusedImports;
  
    /**
     * After the list of [unusedImports] has been computed, this list is a proper subset of the
     * unused imports that are listed more than once.
     */
    List<ImportDirective> _duplicateImports;
  
    /**
     * This is a map between the set of [LibraryElement]s that the current library imports, and
  
negative.code:    */
    InheritanceManager _manager;
  
    GatherUsedLocalElementsVisitor _usedLocalElementsVisitor;
  
    HintGenerator(this._compilationUnits, this._context, this._errorListener) {
      _library = _compilationUnits[0].element.library;
      _usedImportedElementsVisitor =
          new GatherUsedImportedElementsVisitor(_library);
      _enableDart2JSHints = _context.analysisOptions.dart2jsHint;
      _manager = new InheritanceManager(_compilationUnits[0].element.library);
      _usedLocalElementsVisitor = new GatherUsedLocalElementsVisitor(_library);
    }
  
    void generateForLibrary() {
      PerformanceStatistics.hints.makeCurrentWhile(() {
        for (CompilationUnit unit in _compilationUnits) {
          CompilationUnitElement element = unit.element;
          if (element != null) {
            _generateForCompilationUnit(unit, element.source);
          }
        }
        CompilationUnit definingUnit = _compilationUnits[0];
        ErrorReporter definingUnitErrorReporter =
            new ErrorReporter(_errorListener, definingUnit.element.source);
        {
          ImportsVerifier importsVerifier = new ImportsVerifier();
          importsVerifier.addImports(definingUnit);
          importsVerifier
              .removeUsedElements(_usedImportedElementsVisitor.usedElements);
          importsVerifier.generateDuplicateImportHints(definingUnitErrorReporter);
          importsVerifier.generateUnusedImportHints(definingUnitErrorReporter);
        }
        _library.accept(new UnusedLocalElementsVerifier(
            _errorListener, _usedLocalElementsVisitor.usedElements));
      });
    }
  
    void _generateForCompilationUnit(CompilationUnit unit, Source source) {
      ErrorReporter errorReporter = new ErrorReporter(_errorListener, source);
      unit.accept(_usedImportedElementsVisitor);
      // dead code analysis
      unit.accept(new DeadCodeVerifier(errorReporter));
      unit.accept(_usedLocalElementsVisitor);
      // dart2js analysis
      if (_enableDart2JSHints) {
        unit.accept(new Dart2JSVerifier(errorReporter));
  