Adapt the existing incremental resolution implementation to the new model.

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/context/cache.dart'
+    show CacheEntry, TargetedResult;
 import 'package:analyzer/src/generated/constant.dart';
 import 'package:analyzer/src/services/lint.dart';
+import 'package:analyzer/src/task/dart.dart'
+    show
+        HINTS,
+        PARSE_ERRORS,
+        RESOLVE_REFERENCES_ERRORS,
+        RESOLVE_TYPE_NAMES_ERRORS,
+        SCAN_ERRORS,
+        USED_IMPORTED_ELEMENTS,
+        USED_LOCAL_ELEMENTS,
+        VERIFY_ERRORS;
+import 'package:analyzer/task/dart.dart'
+    show LibrarySpecificUnit, PARSED_UNIT, TOKEN_STREAM;
+import 'package:analyzer/task/general.dart' show CONTENT;
+import 'package:analyzer/task/model.dart' show ResultDescriptor;
 
 import 'ast.dart';
 import 'element.dart';
 import 'engine.dart';
 import 'error.dart';
 import 'error_verifier.dart';
 import 'incremental_logger.dart' show logger, LoggingTimer;
 import 'java_engine.dart';
 import 'parser.dart';
 import 'resolver.dart';
@@ skipping 779 matching lines @@
   TypeProvider _typeProvider;
 
   /**
    * The element for the library containing the compilation unit being resolved.
    */
   LibraryElementImpl _definingLibrary;
 
   /**
    * The [DartEntry] corresponding to the source being resolved.
    */
-  DartEntry entry;
+  DartEntry oldEntry;
+
+  /**
+   * The [CacheEntry] corresponding to the source being resolved.
+   */
+  CacheEntry newSourceEntry;
+
+  /**
+   * The [CacheEntry] corresponding to the [LibrarySpecificUnit] being resolved.
+   */
+  CacheEntry newUnitEntry;
 
   /**
    * The source representing the compilation unit being visited.
    */
   Source _source;
 
   /**
    * The source representing the library of the compilation unit being visited.
    */
   Source _librarySource;
@@ skipping 19 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._definingUnit, this._updateOffset,
-      this._updateEndOld, this._updateEndNew) {
+  IncrementalResolver(this.oldEntry, this.newSourceEntry, this.newUnitEntry,
+      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.
    *
    * Returns `true` if resolution was successful.
    */
   bool resolve(AstNode node) {
@@ skipping 195 matching lines @@
         }
         visitor.initForIncrementalResolution();
         node.accept(visitor);
       }
     } finally {
       timer.stop('resolve references');
     }
   }
 
   void _shiftEntryErrors() {
-    _shiftErrors(DartEntry.RESOLUTION_ERRORS);
-    _shiftErrors(DartEntry.VERIFICATION_ERRORS);
-    _shiftErrors(DartEntry.HINTS);
-    _shiftErrors(DartEntry.LINTS);
+    if (oldEntry != null) {
+      _shiftEntryErrors_OLD();
+    } else {
+      _shiftEntryErrors_NEW();
+    }
   }
 
-  void _shiftErrors(DataDescriptor<List<AnalysisError>> descriptor) {
-    List<AnalysisError> errors =
-        entry.getValueInLibrary(descriptor, _librarySource);
+  void _shiftEntryErrors_NEW() {
+    _shiftErrors_NEW(RESOLVE_TYPE_NAMES_ERRORS);
+    _shiftErrors_NEW(RESOLVE_REFERENCES_ERRORS);
+    _shiftErrors_NEW(VERIFY_ERRORS);
+    _shiftErrors_NEW(HINTS);
+  }
+
+  void _shiftEntryErrors_OLD() {
+    _shiftErrors_OLD(DartEntry.RESOLUTION_ERRORS);
+    _shiftErrors_OLD(DartEntry.VERIFICATION_ERRORS);
+    _shiftErrors_OLD(DartEntry.HINTS);
+    _shiftErrors_OLD(DartEntry.LINTS);
+  }
+
+  void _shiftErrors(List<AnalysisError> errors) {
     for (AnalysisError error in errors) {
       int errorOffset = error.offset;
       if (errorOffset > _updateOffset) {
         error.offset += _updateDelta;
       }
     }
   }
 
+  void _shiftErrors_NEW(ResultDescriptor<List<AnalysisError>> descriptor) {
+    List<AnalysisError> errors = newUnitEntry.getValue(descriptor);
+    _shiftErrors(errors);
+  }
+
+  void _shiftErrors_OLD(DataDescriptor<List<AnalysisError>> descriptor) {
+    List<AnalysisError> errors =
+        oldEntry.getValueInLibrary(descriptor, _librarySource);
+    _shiftErrors(errors);
+  }
+
   void _updateElementNameOffsets() {
     LoggingTimer timer = logger.startTimer();
     try {
       _definingUnit
           .accept(new _ElementNameOffsetUpdater(_updateOffset, _updateDelta));
     } finally {
       timer.stop('update element offsets');
     }
   }
 
   void _updateEntry() {
+    if (oldEntry != null) {
+      _updateEntry_OLD();
+    } else {
+      _updateEntry_NEW();
+    }
+  }
+
+  void _updateEntry_NEW() {
+    _updateErrors_NEW(RESOLVE_TYPE_NAMES_ERRORS, []);
+    _updateErrors_NEW(RESOLVE_REFERENCES_ERRORS, _resolveErrors);
+    _updateErrors_NEW(VERIFY_ERRORS, _verifyErrors);
+    // invalidate results we don't update incrementally
+    newUnitEntry.setState(USED_IMPORTED_ELEMENTS, CacheState.INVALID);
+    newUnitEntry.setState(USED_LOCAL_ELEMENTS, CacheState.INVALID);
+    newUnitEntry.setState(HINTS, CacheState.INVALID);
+  }
+
+  void _updateEntry_OLD() {
     {
-      List<AnalysisError> oldErrors =
-          entry.getValueInLibrary(DartEntry.RESOLUTION_ERRORS, _librarySource);
+      List<AnalysisError> oldErrors = oldEntry.getValueInLibrary(
+          DartEntry.RESOLUTION_ERRORS, _librarySource);
       List<AnalysisError> errors = _updateErrors(oldErrors, _resolveErrors);
-      entry.setValueInLibrary(
+      oldEntry.setValueInLibrary(
           DartEntry.RESOLUTION_ERRORS, _librarySource, errors);
     }
     {
-      List<AnalysisError> oldErrors = entry.getValueInLibrary(
+      List<AnalysisError> oldErrors = oldEntry.getValueInLibrary(
           DartEntry.VERIFICATION_ERRORS, _librarySource);
       List<AnalysisError> errors = _updateErrors(oldErrors, _verifyErrors);
-      entry.setValueInLibrary(
+      oldEntry.setValueInLibrary(
           DartEntry.VERIFICATION_ERRORS, _librarySource, errors);
     }
-    entry.setValueInLibrary(DartEntry.LINTS, _librarySource, _lints);
+    oldEntry.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);
       } else if (errorOffset > _updateEndOld) {
         error.offset += _updateDelta;
         errors.add(error);
       }
     }
     // add new errors
     for (AnalysisError error in newErrors) {
       int errorOffset = error.offset;
       if (errorOffset > _updateOffset && errorOffset < _updateEndNew) {
         errors.add(error);
       }
     }
     // done
     return errors;
   }
 
+  void _updateErrors_NEW(ResultDescriptor<List<AnalysisError>> descriptor,
+      List<AnalysisError> newErrors) {
+    List<AnalysisError> oldErrors = newUnitEntry.getValue(descriptor);
+    List<AnalysisError> errors = _updateErrors(oldErrors, newErrors);
+    newUnitEntry.setValueIncremental(descriptor, errors);
+  }
+
   void _verify(AstNode node) {
     LoggingTimer timer = logger.startTimer();
     try {
       RecordingErrorListener errorListener = new RecordingErrorListener();
       ErrorReporter errorReporter = new ErrorReporter(errorListener, _source);
       ErrorVerifier errorVerifier = new ErrorVerifier(errorReporter,
           _definingLibrary, _typeProvider,
           new InheritanceManager(_definingLibrary));
       if (_resolutionContext.enclosingClassDeclaration != null) {
         errorVerifier.visitClassDeclarationIncrementally(
             _resolutionContext.enclosingClassDeclaration);
       }
       node.accept(errorVerifier);
       _verifyErrors = errorListener.getErrorsForSource(_source);
     } finally {
       timer.stop('verify');
     }
   }
 }
 
 class PoorMansIncrementalResolver {
   final TypeProvider _typeProvider;
   final Source _unitSource;
-  final DartEntry _entry;
+
+  /**
+   * The [DartEntry] corresponding to the source being resolved.
+   */
+  DartEntry _oldEntry;
+
+  /**
+   * The [CacheEntry] corresponding to the source being resolved.
+   */
+  CacheEntry _newSourceEntry;
+
+  /**
+   * The [CacheEntry] corresponding to the [LibrarySpecificUnit] being resolved.
+   */
+  CacheEntry _newUnitEntry;
+
   final CompilationUnit _oldUnit;
   final AnalysisOptions _options;
   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,
-      this._oldUnit, bool resolveApiChanges, this._options) {
+  PoorMansIncrementalResolver(this._typeProvider, this._unitSource,
+      this._oldEntry, this._newSourceEntry, this._newUnitEntry, this._oldUnit,
+      bool resolveApiChanges, this._options) {
     _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(String newCode) {
     logger.enter('diff/resolve $_unitSource');
@@ skipping 36 matching lines @@
             bool success = _resolveCommentDoc(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(
-                  _unitElement, _updateOffset, _updateEndOld, _updateEndNew);
+                  _oldEntry, _newSourceEntry, _newUnitEntry, _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.
@@ skipping 64 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(
-            _unitElement, _updateOffset, _updateEndOld, _updateEndNew);
+            _oldEntry, _newSourceEntry, _newUnitEntry, _unitElement,
+            _updateOffset, _updateEndOld, _updateEndNew);
         bool success = incrementalResolver.resolve(newNode);
         // check if success
         if (!success) {
           logger.log('Failure: element model changed.');
           return false;
         }
         // update DartEntry
         _updateEntry();
         logger.log('Success.');
         return true;
@@ skipping 41 matching lines @@
     Comment newComment = _findNodeCovering(newUnit, offset, offset);
     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(
-        _unitElement, _updateOffset, _updateEndOld, _updateEndNew);
+    IncrementalResolver incrementalResolver = new IncrementalResolver(_oldEntry,
+        _newSourceEntry, _newUnitEntry, _unitElement, _updateOffset,
+        _updateEndOld, _updateEndNew);
     incrementalResolver._updateElementNameOffsets();
     incrementalResolver._shiftEntryErrors();
     _updateEntry();
     // resolve references in the comment
     incrementalResolver._resolveReferences(newComment);
     // OK
     return true;
   }
 
   Token _scan(String code) {
@@ skipping 38 matching lines @@
       }
       // next
       if (token.type == TokenType.EOF) {
         break;
       }
       token = token.next;
     }
   }
 
   void _updateEntry() {
-    _entry.setValue(DartEntry.SCAN_ERRORS, _newScanErrors);
-    _entry.setValue(DartEntry.PARSE_ERRORS, _newParseErrors);
+    if (_oldEntry != null) {
+      _updateEntry_OLD();
+    } else {
+      _updateEntry_NEW();
+    }
+  }
+
+  void _updateEntry_NEW() {
+    // scan results
+    _newSourceEntry.setState(SCAN_ERRORS, CacheState.INVALID);
+    List<TargetedResult> scanDeps =
+        <TargetedResult>[new TargetedResult(_unitSource, CONTENT)];
+    _newSourceEntry.setValue(SCAN_ERRORS, _newScanErrors, scanDeps);
+    // parse results
+    List<TargetedResult> parseDeps =
+        <TargetedResult>[new TargetedResult(_unitSource, TOKEN_STREAM)];
+    _newSourceEntry.setState(PARSE_ERRORS, CacheState.INVALID);
+    _newSourceEntry.setValue(PARSE_ERRORS, _newParseErrors, parseDeps);
+    _newSourceEntry.setValue(PARSED_UNIT, _oldUnit, parseDeps);
+  }
+
+  void _updateEntry_OLD() {
+    _oldEntry.setValue(DartEntry.SCAN_ERRORS, _newScanErrors);
+    _oldEntry.setValue(DartEntry.PARSE_ERRORS, _newParseErrors);
   }
 
   /**
    * Checks if [token] has a balanced number of open and closed curly brackets.
    */
   static bool _areCurlyBracketsBalanced(Token token) {
     int numOpen = _getTokenCount(token, TokenType.OPEN_CURLY_BRACKET);
     int numOpen2 =
         _getTokenCount(token, TokenType.STRING_INTERPOLATION_EXPRESSION);
     int numClosed = _getTokenCount(token, TokenType.CLOSE_CURLY_BRACKET);
@@ skipping 390 matching lines @@
   @override
   String toString() => name;
 }
 
 class _TokenPair {
   final _TokenDifferenceKind kind;
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.kind, this.oldToken, this.newToken);
 }