Initial version of limiting invalidation.

pkg/analyzer/lib/src/context/cache.dart

 // Copyright (c) 2015, 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 analyzer.src.context.cache;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/engine.dart'
@@ skipping 394 matching lines @@
     this._exception = exception;
     for (ResultDescriptor descriptor in descriptors) {
       _setErrorState(descriptor, exception);
     }
   }
 
   /**
    * Set the state of the result represented by the given [descriptor] to the
    * given [state].
    */
-  void setState(ResultDescriptor descriptor, CacheState state) {
+  void setState(ResultDescriptor descriptor, CacheState state, {Delta delta}) {
     if (state == CacheState.ERROR) {
       throw new ArgumentError('use setErrorState() to set the state to ERROR');
     }
     if (state == CacheState.VALID) {
       throw new ArgumentError('use setValue() to set the state to VALID');
     }
     _validateStateChange(descriptor, state);
     if (state == CacheState.INVALID) {
       ResultData data = _resultMap[descriptor];
       if (data != null) {
-        _invalidate(descriptor);
+        _invalidate(descriptor, delta);
       }
     } else {
       ResultData data = getResultData(descriptor);
       data.state = state;
       if (state != CacheState.IN_PROCESS) {
         //
         // If the state is in-process, we can leave the current value in the
         // cache for any 'get' methods to access.
         //
         data.value = descriptor.defaultValue;
@@ skipping 27 matching lines @@
     data.value = value == null ? descriptor.defaultValue : value;
   }
 
   /**
    * Set the value of the result represented by the given [descriptor] to the
    * given [value], keep its dependency, invalidate all the dependent result.
    */
   void setValueIncremental(ResultDescriptor descriptor, dynamic value) {
     ResultData data = getResultData(descriptor);
     List<TargetedResult> dependedOn = data.dependedOnResults;
-    _invalidate(descriptor);
+    _invalidate(descriptor, null);
     setValue(descriptor, value, dependedOn);
   }
 
   @override
   String toString() {
     StringBuffer buffer = new StringBuffer();
     _writeOn(buffer);
     return buffer.toString();
   }
 
   /**
    * Return the value of the flag with the given [index].
    */
   bool _getFlag(int index) => BooleanArray.get(_flags, index);
 
   /**
    * Invalidate the result represented by the given [descriptor] and propagate
    * invalidation to other results that depend on it.
    */
-  void _invalidate(ResultDescriptor descriptor) {
+  void _invalidate(ResultDescriptor descriptor, Delta delta) {
+    if (delta != null &&
+        !delta.affects(_partition.context, target, descriptor)) {
+//      print('not-invalidate $descriptor for $target');
+      return;
+    }
 //    print('invalidate $descriptor for $target');
     ResultData thisData = _resultMap.remove(descriptor);
     if (thisData == null) {
       return;
     }
     // Stop depending on other results.
     TargetedResult thisResult = new TargetedResult(target, descriptor);
     thisData.dependedOnResults.forEach((TargetedResult dependedOnResult) {
       ResultData data = _partition._getDataFor(dependedOnResult, orNull: true);
       if (data != null) {
         data.dependentResults.remove(thisResult);
       }
     });
     // Invalidate results that depend on this result.
     Set<TargetedResult> dependentResults = thisData.dependentResults;
     thisData.dependentResults = new Set<TargetedResult>();
     dependentResults.forEach((TargetedResult dependentResult) {
       CacheEntry entry = _partition.get(dependentResult.target);
       if (entry != null) {
-        entry._invalidate(dependentResult.result);
+        entry._invalidate(dependentResult.result, delta);
       }
     });
     // If empty, remove the entry altogether.
     if (_resultMap.isEmpty) {
       _partition._targetMap.remove(target);
       _partition._removeIfSource(target);
     }
     // Notify controller.
     _partition._onResultInvalidated
         .add(new InvalidatedResult(this, descriptor));
   }
 
   /**
    * Invalidates all the results of this entry, with propagation.
    */
   void _invalidateAll() {
     List<ResultDescriptor> results = _resultMap.keys.toList();
     for (ResultDescriptor result in results) {
-      _invalidate(result);
+      _invalidate(result, null);
     }
   }
 
   /**
    * Set the [dependedOn] on which this result depends.
    */
   void _setDependedOnResults(ResultData thisData, TargetedResult thisResult,
       List<TargetedResult> dependedOn) {
     thisData.dependedOnResults.forEach((TargetedResult dependedOnResult) {
       ResultData data = _partition._getDataFor(dependedOnResult, orNull: true);
@@ skipping 409 matching lines @@
           if (sources.isEmpty) {
             _pathToSources.remove(fullName);
           }
         }
       }
     }
   }
 }
 
 /**
+ * The description for a change.
+ */
+class Delta {
+  final Source source;
+
+  Delta(this.source);
+
+  /**
+   * Check whether this delta affects the result described by the given
+   * [descriptor] and [target].
+   */
+  bool affects(InternalAnalysisContext context, AnalysisTarget target,
+      ResultDescriptor descriptor) {
+    return true;
+  }
+}
+
+/**
  * [InvalidatedResult] describes an invalidated result.
  */
 class InvalidatedResult {
   /**
    * The target in which the result was invalidated.
    */
   final CacheEntry entry;
 
   /**
    * The descriptor of the result which was invalidated.
@@ skipping 142 matching lines @@
   void resultAccessed(TargetedResult result) {}
 
   @override
   List<TargetedResult> resultStored(TargetedResult newResult, newValue) {
     return TargetedResult.EMPTY_LIST;
   }
 
   @override
   void targetRemoved(AnalysisTarget target) {}
 }