anchor.diff:        _libraryMap[libraryElement] = importList;
       }
       importList.add(importDirective);
  -  }
  -
  -  Object _visitIdentifier(Element element, String name) {
  -    if (element == null) {
  -      return null;
  -    }
  -    // If the element is multiply defined then call this method recursively for
  -    // each of the conflicting elements.
  -    if (element is MultiplyDefinedElement) {
  -      MultiplyDefinedElement multiplyDefinedElement = element;
  -      for (Element elt in multiplyDefinedElement.conflictingElements) {
  -        _visitIdentifier(elt, name);
  -      }
  -      return null;
  -    } else if (element is PrefixElement) {
  -      List<ImportDirective> importDirectives = _prefixElementMap[element];
  -      if (importDirectives != null) {
  -        for (ImportDirective importDirective in importDirectives) {
  -          _unusedImports.remove(importDirective);
  -        }
  -      }
  -      return null;
  -    } else if (element.enclosingElement is! CompilationUnitElement) {
  -      // Identifiers that aren't a prefix element and whose enclosing element
  -      // isn't a CompilationUnit are ignored- this covers the case the
  -      // identifier is a relative-reference, a reference to an identifier not
  -      // imported by this library.
  -      return null;
  -    }
  -    LibraryElement containingLibrary = element.library;
  -    if (containingLibrary == null) {
  -      return null;
  -    }
  -    // If the element is declared in the current library, return.
  -    if (_currentLibrary == containingLibrary) {
  -      return null;
  -    }
  -    List<ImportDirective> importsFromSameLibrary =
  -        _libraryMap[containingLibrary];
  -    if (importsFromSameLibrary == null) {
  -      return null;
  -    }
  -    if (importsFromSameLibrary.length == 1) {
  -      // If there is only one import directive for this library, then it must be
  -      // the directive that this element is imported with, remove it from the
  -      // unusedImports list.
  -      ImportDirective usedImportDirective = importsFromSameLibrary[0];
  -      _unusedImports.remove(usedImportDirective);
  -    } else {
  -      // Otherwise, for each of the imported directives, use the namespaceMap to
  -      for (ImportDirective importDirective in importsFromSameLibrary) {
  -        // Get the namespace for this import
  -        Namespace namespace = _computeNamespace(importDirective);
  -        if (namespace != null && namespace.get(name) != null) {
  -          _unusedImports.remove(importDirective);
  -        }
  -      }
  -    }
  -    return null;
  -  }
  -
  -  /**
  -   * Given some [NodeList] of [Annotation]s, ensure that the identifiers are visited by
  -   * this visitor. Specifically, this covers the cases where AST nodes don't have their identifiers
  -   * visited by this visitor, but still need their annotations visited.
  -   *
  -   * @param annotations the list of annotations to visit
  -   */
  -  void _visitMetadata(NodeList<Annotation> annotations) {
  -    int count = annotations.length;
  -    for (int i = 0; i < count; i++) {
  -      annotations[i].accept(this);
  -    }
     }
   }
   
  
positive.code:    * [Namespace] for each of the imports to do lookups in the same way that they are done from
     * the [ElementResolver].
     */
    HashMap<ImportDirective, Namespace> _namespaceMap;
  
    /**
     * This is a map between prefix elements and the import directives from which they are derived. In
  
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));
  