Use all library units for hints during incremental resolution.

pkg/analyzer/lib/src/generated/incremental_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.incremental_resolver;
 
 import 'dart:collection';
 import 'dart:math' as math;
 
 import 'ast.dart';
@@ skipping 757 matching lines @@
   String toString() => name;
 }
 
 
 /**
  * Instances of the class [IncrementalResolver] resolve the smallest portion of
  * an AST structure that we currently know how to resolve.
  */
 class IncrementalResolver {
   /**
+   * All resolved units of the [_definingLibrary].
+   */
+  final Map<Source, CompilationUnit> _units;
+
+  /**
    * The element of the compilation unit being resolved.
    */
   final CompilationUnitElement _definingUnit;
 
   /**
    * The context the compilation unit being resolved in.
    */
   AnalysisContextImpl _context;
 
   /**
@@ skipping 10 matching lines @@
    * The [DartEntry] corresponding to the source being resolved.
    */
   DartEntry entry;
 
   /**
    * The source representing the compilation unit being visited.
    */
   Source _source;
 
   /**
+   * The source representing the library of the compilation unit being visited.
+   */
+  Source _librarySource;
+
+  /**
    * The offset of the changed contents.
    */
   final int _updateOffset;
 
   /**
    * The end of the changed contents in the old unit.
    */
   final int _updateEndOld;
 
   /**
    * The end of the changed contents in the new unit.
    */
   final int _updateEndNew;
 
   int _updateDelta;
 
   RecordingErrorListener errorListener = new RecordingErrorListener();
   ResolutionContext _resolutionContext;
 
   List<AnalysisError> _resolveErrors = AnalysisError.NO_ERRORS;
   List<AnalysisError> _verifyErrors = AnalysisError.NO_ERRORS;
-  List<AnalysisError> _hints = AnalysisError.NO_ERRORS;
   List<AnalysisError> _lints = AnalysisError.NO_ERRORS;
 
   /**
    * The elements that should be resolved because of API changes.
    */
   HashSet<Element> _resolutionQueue = new HashSet<Element>();
 
   /**
    * Initialize a newly created incremental resolver to resolve a node in the
    * given source in the given library.
    */
-  IncrementalResolver(this._definingUnit, this._updateOffset,
+  IncrementalResolver(this._units, this._definingUnit, this._updateOffset,
       this._updateEndOld, this._updateEndNew) {
     _updateDelta = _updateEndNew - _updateEndOld;
     _definingLibrary = _definingUnit.library;
+    _librarySource = _definingLibrary.source;
     _source = _definingUnit.source;
     _context = _definingUnit.context;
     _typeProvider = _context.typeProvider;
     entry = _context.getReadableSourceEntryOrNull(_source);
   }
 
   /**
    * Resolve [node], reporting any errors or warnings to the given listener.
    *
    * [node] - the root of the AST structure to be resolved.
@@ skipping 126 matching lines @@
       }
       node = node.parent;
     }
     throw new AnalysisException("Cannot resolve node: no resolvable node");
   }
 
   void _generateHints(AstNode node) {
     LoggingTimer timer = logger.startTimer();
     try {
       RecordingErrorListener errorListener = new RecordingErrorListener();
-      CompilationUnit unit = node.getAncestor((n) => n is CompilationUnit);
+      // prepare a list of the library units
+      List<CompilationUnit> units;
+      {
+        CompilationUnit unit = node.getAncestor((n) => n is CompilationUnit);
+        _units[_source] = unit;
+        units = _units.values.toList();
+      }
+      // run the generator
       AnalysisContext analysisContext = _definingLibrary.context;
       HintGenerator hintGenerator =
-          new HintGenerator(<CompilationUnit>[unit], analysisContext, errorListener);
+          new HintGenerator(units, analysisContext, errorListener);
       hintGenerator.generateForLibrary();
-      _hints = errorListener.getErrorsForSource(_source);
+      // remember hints
+      for (Source source in _units.keys) {
+        List<AnalysisError> hints = errorListener.getErrorsForSource(source);
+        DartEntry entry = _context.getReadableSourceEntryOrNull(source);
+        entry.setValueInLibrary(DartEntry.HINTS, _librarySource, hints);
+      }
     } finally {
       timer.stop('generate hints');
     }
   }
 
   void _generateLints(AstNode node) {
     LoggingTimer timer = logger.startTimer();
     try {
       RecordingErrorListener errorListener = new RecordingErrorListener();
       CompilationUnit unit = node.getAncestor((n) => n is CompilationUnit);
@@ skipping 37 matching lines @@
     logger.log('${_resolutionQueue.length} elements in the resolution queue');
     for (Element element in _resolutionQueue) {
       // TODO(scheglov) in general, we should not call Element.node, it
       // might perform complete unit resolution.
       logger.enter('resolve $element');
       try {
         AstNode node = element.node;
         CompilationUnitElement unit =
             element.getAncestor((e) => e is CompilationUnitElement);
         IncrementalResolver resolver =
-            new IncrementalResolver(unit, node.offset, node.end, node.end);
+            new IncrementalResolver(_units, unit, node.offset, node.end, node.end);
         resolver._resolveReferences(node);
         resolver._verify(node);
         resolver._generateHints(node);
         resolver._generateLints(node);
         resolver._updateEntry();
       } finally {
         logger.exit();
       }
     }
   }
@@ skipping 50 matching lines @@
   }
 
   void _shiftEntryErrors() {
     _shiftErrors(DartEntry.RESOLUTION_ERRORS);
     _shiftErrors(DartEntry.VERIFICATION_ERRORS);
     _shiftErrors(DartEntry.HINTS);
     _shiftErrors(DartEntry.LINTS);
   }
 
   void _shiftErrors(DataDescriptor<List<AnalysisError>> descriptor) {
-    Source librarySource = _definingLibrary.source;
     List<AnalysisError> errors =
-        entry.getValueInLibrary(descriptor, librarySource);
+        entry.getValueInLibrary(descriptor, _librarySource);
     for (AnalysisError error in errors) {
       int errorOffset = error.offset;
       if (errorOffset > _updateOffset) {
         error.offset += _updateDelta;
       }
     }
   }
 
   void _updateElementNameOffsets() {
     LoggingTimer timer = logger.startTimer();
     try {
       _definingUnit.accept(
           new _ElementNameOffsetUpdater(_updateOffset, _updateDelta));
     } finally {
       timer.stop('update element offsets');
     }
   }
 
   void _updateEntry() {
-    Source librarySource = _definingLibrary.source;
     {
       List<AnalysisError> oldErrors =
-          entry.getValueInLibrary(DartEntry.RESOLUTION_ERRORS, librarySource);
+          entry.getValueInLibrary(DartEntry.RESOLUTION_ERRORS, _librarySource);
       List<AnalysisError> errors = _updateErrors(oldErrors, _resolveErrors);
       entry.setValueInLibrary(
           DartEntry.RESOLUTION_ERRORS,
-          librarySource,
+          _librarySource,
           errors);
     }
     {
       List<AnalysisError> oldErrors =
-          entry.getValueInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource);
+          entry.getValueInLibrary(DartEntry.VERIFICATION_ERRORS, _librarySource);
       List<AnalysisError> errors = _updateErrors(oldErrors, _verifyErrors);
       entry.setValueInLibrary(
           DartEntry.VERIFICATION_ERRORS,
-          librarySource,
+          _librarySource,
           errors);
     }
-    entry.setValueInLibrary(DartEntry.HINTS, librarySource, _hints);
-    entry.setValueInLibrary(DartEntry.LINTS, librarySource, _lints);
+    entry.setValueInLibrary(DartEntry.LINTS, _librarySource, _lints);
   }
 
   List<AnalysisError> _updateErrors(List<AnalysisError> oldErrors,
       List<AnalysisError> newErrors) {
     List<AnalysisError> errors = new List<AnalysisError>();
     // add updated old errors
     for (AnalysisError error in oldErrors) {
       int errorOffset = error.offset;
       if (errorOffset < _updateOffset) {
         errors.add(error);
@@ skipping 31 matching lines @@
       _verifyErrors = errorListener.getErrorsForSource(_source);
     } finally {
       timer.stop('verify');
     }
   }
 }
 
 
 class PoorMansIncrementalResolver {
   final TypeProvider _typeProvider;
+  final Map<Source, CompilationUnit> _units;
   final Source _unitSource;
   final DartEntry _entry;
   CompilationUnitElement _unitElement;
 
   int _updateOffset;
   int _updateDelta;
   int _updateEndOld;
   int _updateEndNew;
 
   List<AnalysisError> _newScanErrors = <AnalysisError>[];
   List<AnalysisError> _newParseErrors = <AnalysisError>[];
 
-  PoorMansIncrementalResolver(this._typeProvider, this._unitSource, this._entry,
-      bool resolveApiChanges) {
+  PoorMansIncrementalResolver(this._typeProvider, this._units, this._unitSource,
+      this._entry, bool resolveApiChanges) {
     _resolveApiChanges = resolveApiChanges;
   }
 
   /**
    * Attempts to update [oldUnit] to the state corresponding to [newCode].
    * Returns `true` if success, or `false` otherwise.
    * The [oldUnit] might be damaged.
    */
-  bool resolve(CompilationUnit oldUnit, String newCode) {
+  bool resolve(String newCode) {
     logger.enter('diff/resolve $_unitSource');
     try {
+      CompilationUnit oldUnit = _units[_unitSource];
       _unitElement = oldUnit.element;
       CompilationUnit newUnit = _parseUnit(newCode);
       _TokenPair firstPair =
           _findFirstDifferentToken(oldUnit.beginToken, newUnit.beginToken);
       _TokenPair lastPair =
           _findLastDifferentToken(oldUnit.endToken, newUnit.endToken);
       if (firstPair != null && lastPair != null) {
         int firstOffsetOld = firstPair.oldToken.offset;
         int firstOffsetNew = firstPair.newToken.offset;
         int lastOffsetOld = lastPair.oldToken.end;
@@ skipping 14 matching lines @@
             bool success = _resolveComment(oldUnit, newUnit, firstPair);
             logger.log('Documentation comment resolved: $success');
             return success;
           }
           // A pure whitespace change.
           if (firstPair.kind == _TokenDifferenceKind.OFFSET) {
             logger.log('Whitespace change.');
             _shiftTokens(firstPair.oldToken);
             {
               IncrementalResolver incrementalResolver = new IncrementalResolver(
+                  _units,
                   _unitElement,
                   _updateOffset,
                   _updateEndOld,
                   _updateEndNew);
               incrementalResolver._updateElementNameOffsets();
               incrementalResolver._shiftEntryErrors();
             }
             _updateEntry();
             logger.log('Success.');
             return true;
@@ skipping 52 matching lines @@
           if (oldBeginToken.previous.type == TokenType.EOF) {
             oldUnit.beginToken = newBeginToken;
           } else {
             oldBeginToken.previous.setNext(newBeginToken);
           }
           newNode.endToken.setNext(oldNode.endToken.next);
           _shiftTokens(oldNode.endToken.next);
         }
         // perform incremental resolution
         IncrementalResolver incrementalResolver = new IncrementalResolver(
+            _units,
             _unitElement,
             _updateOffset,
             _updateEndOld,
             _updateEndNew);
         bool success = incrementalResolver.resolve(newNode);
         // check if success
         if (!success) {
           logger.log('Failure: element model changed.');
           return false;
         }
@@ skipping 47 matching lines @@
     logger.log('oldComment.beginToken: ${oldComment.beginToken}');
     logger.log('newComment.beginToken: ${newComment.beginToken}');
     _updateOffset = oldToken.offset - 1;
     // update token references
     _shiftTokens(firstPair.oldToken);
     _setPrecedingComments(oldToken, newComment.tokens.first);
     // replace node
     NodeReplacer.replace(oldComment, newComment);
     // update elements
     IncrementalResolver incrementalResolver = new IncrementalResolver(
+        _units,
         _unitElement,
         _updateOffset,
         _updateEndOld,
         _updateEndNew);
     incrementalResolver._updateElementNameOffsets();
     incrementalResolver._shiftEntryErrors();
     _updateEntry();
     // resolve references in the comment
     incrementalResolver._resolveReferences(newComment);
     // OK
@@ skipping 430 matching lines @@
   String toString() => name;
 }
 
 
 class _TokenPair {
   final _TokenDifferenceKind kind;
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.kind, this.oldToken, this.newToken);
 }