Invalidate hints instead of computing them in the incremental resolver.

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 'package:analyzer/src/services/lint.dart';
@@ skipping 769 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 42 matching lines @@
   ResolutionContext _resolutionContext;
 
   List<AnalysisError> _resolveErrors = AnalysisError.NO_ERRORS;
   List<AnalysisError> _verifyErrors = AnalysisError.NO_ERRORS;
   List<AnalysisError> _lints = AnalysisError.NO_ERRORS;
 
   /**
    * Initialize a newly created incremental resolver to resolve a node in the
    * given source in the given library.
    */
-  IncrementalResolver(this._units, this._definingUnit, this._updateOffset,
+  IncrementalResolver(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);
   }
 
@@ skipping 12 matching lines @@
       // update elements
       _updateElementNameOffsets();
       _buildElements(rootNode);
       if (!_canBeIncrementallyResolved(rootNode)) {
         return false;
       }
       // resolve
       _resolveReferences(rootNode);
       // verify
       _verify(rootNode);
-      _generateHints(rootNode);
+      _context.invalidateLibraryHints(_librarySource);
       _generateLints(rootNode);
       // update entry errors
       _updateEntry();
       // OK
       return true;
     } finally {
       logger.exit();
     }
   }
 
@@ skipping 70 matching lines @@
   AstNode _findResolutionRoot(AstNode node) {
     while (node != null) {
       if (_canBeResolved(node)) {
         return node;
       }
       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();
-      // 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(units, analysisContext, errorListener);
-      hintGenerator.generateForLibrary();
-      // 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);
       LintGenerator lintGenerator =
           new LintGenerator(<CompilationUnit>[unit], errorListener);
       lintGenerator.generate();
       _lints = errorListener.getErrorsForSource(_source);
     } finally {
@@ skipping 164 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;
+  final CompilationUnit _oldUnit;
   CompilationUnitElement _unitElement;
 
   int _updateOffset;
   int _updateDelta;
   int _updateEndOld;
   int _updateEndNew;
 
   List<AnalysisError> _newScanErrors = <AnalysisError>[];
   List<AnalysisError> _newParseErrors = <AnalysisError>[];
 
-  PoorMansIncrementalResolver(this._typeProvider, this._units, this._unitSource,
-      this._entry, bool resolveApiChanges) {
+  PoorMansIncrementalResolver(this._typeProvider, this._unitSource,
+      this._entry, this._oldUnit, bool resolveApiChanges) {
     _resolveApiChanges = resolveApiChanges;
   }
 
   /**
-   * Attempts to update [oldUnit] to the state corresponding to [newCode].
+   * Attempts to update [_oldUnit] to the state corresponding to [newCode].
    * Returns `true` if success, or `false` otherwise.
-   * The [oldUnit] might be damaged.
+   * The [_oldUnit] might be damaged.
    */
   bool resolve(String newCode) {
     logger.enter('diff/resolve $_unitSource');
     try {
       // prepare old unit
-      CompilationUnit oldUnit = _units[_unitSource];
-      if (!_areCurlyBracketsBalanced(oldUnit.beginToken)) {
+      if (!_areCurlyBracketsBalanced(_oldUnit.beginToken)) {
         logger.log('Unbalanced number of curly brackets in the old unit.');
         return false;
       }
-      _unitElement = oldUnit.element;
+      _unitElement = _oldUnit.element;
       // prepare new unit
       CompilationUnit newUnit = _parseUnit(newCode);
       if (!_areCurlyBracketsBalanced(newUnit.beginToken)) {
         logger.log('Unbalanced number of curly brackets in the new unit.');
         return false;
       }
       // find difference
       _TokenPair firstPair =
-          _findFirstDifferentToken(oldUnit.beginToken, newUnit.beginToken);
+          _findFirstDifferentToken(_oldUnit.beginToken, newUnit.beginToken);
       _TokenPair lastPair =
-          _findLastDifferentToken(oldUnit.endToken, newUnit.endToken);
+          _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;
         int lastOffsetNew = lastPair.newToken.end;
         int beginOffsetOld = math.min(firstOffsetOld, lastOffsetOld);
         int endOffsetOld = math.max(firstOffsetOld, lastOffsetOld);
         int beginOffsetNew = math.min(firstOffsetNew, lastOffsetNew);
         int endOffsetNew = math.max(firstOffsetNew, lastOffsetNew);
         // check for a whitespace only change
         if (identical(lastPair.oldToken, firstPair.oldToken) &&
             identical(lastPair.newToken, firstPair.newToken)) {
           _updateOffset = beginOffsetOld - 1;
           _updateEndOld = endOffsetOld;
           _updateEndNew = endOffsetNew;
-          _updateDelta = newUnit.length - oldUnit.length;
+          _updateDelta = newUnit.length - _oldUnit.length;
           // A Dart documentation comment change.
           if (firstPair.kind == _TokenDifferenceKind.COMMENT_DOC) {
-            bool success = _resolveComment(oldUnit, newUnit, firstPair);
+            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;
           }
           // fall-through, end-of-line comment
         }
         // Find nodes covering the "old" and "new" token ranges.
         AstNode oldNode =
-            _findNodeCovering(oldUnit, beginOffsetOld, endOffsetOld);
+            _findNodeCovering(_oldUnit, beginOffsetOld, endOffsetOld);
         AstNode newNode =
             _findNodeCovering(newUnit, beginOffsetNew, endOffsetNew);
         logger.log(() => 'oldNode: $oldNode');
         logger.log(() => 'newNode: $newNode');
         // Try to find the smallest common node, a FunctionBody currently.
         {
           List<AstNode> oldParents = _getParents(oldNode);
           List<AstNode> newParents = _getParents(newNode);
           int length = math.min(oldParents.length, newParents.length);
           bool found = false;
@@ skipping 27 matching lines @@
         _updateEndOld = oldNode.end;
         _updateEndNew = newNode.end;
         _updateDelta = _updateEndNew - _updateEndOld;
         // replace node
         NodeReplacer.replace(oldNode, newNode);
         // update token references
         {
           Token oldBeginToken = _getBeginTokenNotComment(oldNode);
           Token newBeginToken = _getBeginTokenNotComment(newNode);
           if (oldBeginToken.previous.type == TokenType.EOF) {
-            oldUnit.beginToken = newBeginToken;
+            _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 455 matching lines @@
   String toString() => name;
 }
 
 
 class _TokenPair {
   final _TokenDifferenceKind kind;
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.kind, this.oldToken, this.newToken);
 }