Keep known valid Dart results and invalidate all the other results 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 'package:analyzer/src/context/cache.dart'
-    show CacheEntry, TargetedResult;
+    show CacheEntry, Delta, DeltaResult, TargetedResult;
 import 'package:analyzer/src/generated/constant.dart';
-import 'package:analyzer/src/task/dart.dart'
-    show
-        HINTS,
-        INFER_STATIC_VARIABLE_TYPES_ERRORS,
-        LIBRARY_UNIT_ERRORS,
-        PARSE_ERRORS,
-        PARTIALLY_RESOLVE_REFERENCES_ERRORS,
-        RESOLVE_FUNCTION_BODIES_ERRORS,
-        RESOLVE_TYPE_NAMES_ERRORS,
-        SCAN_ERRORS,
-        USED_IMPORTED_ELEMENTS,
-        USED_LOCAL_ELEMENTS,
-        VARIABLE_REFERENCE_ERRORS,
-        VERIFY_ERRORS;
-import 'package:analyzer/task/dart.dart'
-    show DART_ERRORS, LibrarySpecificUnit, PARSED_UNIT, TOKEN_STREAM;
+import 'package:analyzer/src/task/dart.dart';
+import 'package:analyzer/task/dart.dart';
 import 'package:analyzer/task/general.dart' show CONTENT, LINE_INFO;
-import 'package:analyzer/task/model.dart' show ResultDescriptor, TargetedResult;
+import 'package:analyzer/task/model.dart'
+    show AnalysisTarget, ResultDescriptor, TargetedResult, TaskDescriptor;
 
 import 'ast.dart';
 import 'element.dart';
-import 'engine.dart';
+import 'engine.dart'
+    show
+        AnalysisContext,
+        AnalysisOptions,
+        CacheState,
+        DartEntry,
+        DataDescriptor,
+        InternalAnalysisContext,
+        RecordingErrorListener,
+        SourceEntry;
 import 'error.dart';
 import 'error_verifier.dart';
 import 'incremental_logger.dart' show logger, LoggingTimer;
 import 'java_engine.dart';
 import 'parser.dart';
 import 'resolver.dart';
 import 'scanner.dart';
 import 'source.dart';
 import 'utilities_dart.dart';
 
@@ skipping 778 matching lines @@
 
   final String name;
 
   const DeclarationMatchKind(this.name);
 
   @override
   String toString() => name;
 }
 
 /**
+ * The [Delta] implementation used by incremental resolver.
+ * It keeps Dart results that are either don't change or are updated.
+ */
+class IncrementalBodyDelta extends Delta {
+  /**
+   * 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;
+
+  /**
+   * The delta between [updateEndNew] and [updateEndOld].
+   */
+  final int updateDelta;
+
+  IncrementalBodyDelta(Source source, this.updateOffset, this.updateEndOld,
+      this.updateEndNew, this.updateDelta)
+      : super(source);
+
+  @override
+  DeltaResult validate(InternalAnalysisContext context, AnalysisTarget target,
+      ResultDescriptor descriptor) {
+    // don't invalidate results of standard Dart tasks
+    bool isByTask(TaskDescriptor taskDescriptor) {
+      return taskDescriptor.results.contains(descriptor);
+    }
+    if (descriptor == CONTENT) {
+      return DeltaResult.KEEP_CONTINUE;
+    }
+    if (isByTask(BuildCompilationUnitElementTask.DESCRIPTOR) ||
+        isByTask(BuildDirectiveElementsTask.DESCRIPTOR) ||
+        isByTask(BuildEnumMemberElementsTask.DESCRIPTOR) ||
+        isByTask(BuildExportNamespaceTask.DESCRIPTOR) ||
+        isByTask(BuildLibraryElementTask.DESCRIPTOR) ||
+        isByTask(BuildPublicNamespaceTask.DESCRIPTOR) ||
+        isByTask(BuildSourceExportClosureTask.DESCRIPTOR) ||
+        isByTask(BuildSourceImportExportClosureTask.DESCRIPTOR) ||
+        isByTask(ComputeConstantDependenciesTask.DESCRIPTOR) ||
+        isByTask(ComputeConstantValueTask.DESCRIPTOR) ||
+        isByTask(EvaluateUnitConstantsTask.DESCRIPTOR) ||
+        isByTask(InferInstanceMembersInUnitTask.DESCRIPTOR) ||
+        isByTask(InferStaticVariableTypesInUnitTask.DESCRIPTOR) ||
+        isByTask(ParseDartTask.DESCRIPTOR) ||
+        isByTask(PartiallyResolveUnitReferencesTask.DESCRIPTOR) ||
+        isByTask(ScanDartTask.DESCRIPTOR) ||
+        isByTask(ResolveFunctionBodiesInUnitTask.DESCRIPTOR) ||
+        isByTask(ResolveLibraryReferencesTask.DESCRIPTOR) ||
+        isByTask(ResolveLibraryTypeNamesTask.DESCRIPTOR) ||
+        isByTask(ResolveUnitTypeNamesTask.DESCRIPTOR) ||
+        isByTask(ResolveVariableReferencesTask.DESCRIPTOR) ||
+        isByTask(VerifyUnitTask.DESCRIPTOR) ||
+        false) {

[Brian Wilkerson, 2015/09/10 20:06:51]

???

+      return DeltaResult.KEEP_CONTINUE;
+    }
+    // invalidate all the other results
+    return DeltaResult.INVALIDATE;
+  }
+}
+
+/**
  * Instances of the class [IncrementalResolver] resolve the smallest portion of
  * an AST structure that we currently know how to resolve.
  */
 class IncrementalResolver {
   /**
    * The element of the compilation unit being resolved.
    */
   final CompilationUnitElementImpl _definingUnit;
 
   /**
@@ skipping 44 matching lines @@
   /**
    * 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;
 
+  /**
+   * The delta between [_updateEndNew] and [_updateEndOld].
+   */
   int _updateDelta;
 
   /**
    * The set of [AnalysisError]s that have been already shifted.
    */
   Set<AnalysisError> _alreadyShiftedErrors = new HashSet.identity();
 
   RecordingErrorListener errorListener = new RecordingErrorListener();
   ResolutionContext _resolutionContext;
 
@@ skipping 26 matching lines @@
    * [node] - the root of the AST structure to be resolved.
    *
    * Returns `true` if resolution was successful.
    */
   bool resolve(AstNode node) {
     logger.enter('resolve: $_definingUnit');
     try {
       AstNode rootNode = _findResolutionRoot(node);
       _prepareResolutionContext(rootNode);
       // update elements
+      _updateCache();
       _updateElementNameOffsets();
       _buildElements(rootNode);
       if (!_canBeIncrementallyResolved(rootNode)) {
         return false;
       }
       // resolve
       _resolveReferences(rootNode);
       _computeConstants(rootNode);
       _resolveErrors = errorListener.getErrorsForSource(_source);
       // verify
@@ skipping 211 matching lines @@
     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 _updateCache() {
+    if (newSourceEntry != null) {
+      newSourceEntry.setState(CONTENT, CacheState.INVALID,
+          delta: new IncrementalBodyDelta(_source, _updateOffset, _updateEndOld,
+              _updateEndNew, _updateDelta));
+    }
+  }
+
   void _updateElementNameOffsets() {
     LoggingTimer timer = logger.startTimer();
     try {
       _definingUnit
           .accept(new _ElementNameOffsetUpdater(_updateOffset, _updateDelta));
     } finally {
       timer.stop('update element offsets');
     }
   }
 
@@ skipping 183 matching lines @@
             _shiftTokens(firstPair.oldToken);
             {
               IncrementalResolver incrementalResolver = new IncrementalResolver(
                   _oldEntry,
                   _newSourceEntry,
                   _newUnitEntry,
                   _unitElement,
                   _updateOffset,
                   _updateEndOld,
                   _updateEndNew);
+              incrementalResolver._updateCache();
               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 147 matching lines @@
     NodeReplacer.replace(oldComment, newComment);
     // update elements
     IncrementalResolver incrementalResolver = new IncrementalResolver(
         _oldEntry,
         _newSourceEntry,
         _newUnitEntry,
         _unitElement,
         _updateOffset,
         _updateEndOld,
         _updateEndNew);
+    incrementalResolver._updateCache();
     incrementalResolver._updateElementNameOffsets();
     incrementalResolver._shiftEntryErrors();
     _updateEntry();
     // resolve references in the comment
     incrementalResolver._resolveReferences(newComment);
     // OK
     return true;
   }
 
   Token _scan(String code) {
@@ skipping 48 matching lines @@
     if (_oldEntry != null) {
       _updateEntry_OLD();
     } else {
       _updateEntry_NEW();
     }
   }
 
   void _updateEntry_NEW() {
     _newSourceEntry.setState(DART_ERRORS, CacheState.INVALID);
     // scan results
-    _newSourceEntry.setState(SCAN_ERRORS, CacheState.INVALID);
     List<TargetedResult> scanDeps = <TargetedResult>[
       new TargetedResult(_unitSource, CONTENT)
     ];
+    _newSourceEntry.setState(SCAN_ERRORS, CacheState.INVALID);
+    _newSourceEntry.setValue(SCAN_ERRORS, _newScanErrors, scanDeps);
     _newSourceEntry.setValue(LINE_INFO, _newLineInfo, scanDeps);
-    _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() {
@@ skipping 403 matching lines @@
   @override
   String toString() => name;
 }
 
 class _TokenPair {
   final _TokenDifferenceKind kind;
   final Token oldToken;
   final Token newToken;
   _TokenPair(this.kind, this.oldToken, this.newToken);
 }