Removed fixed dependencies

packages/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'
-    show AnalysisEngine, CacheState, InternalAnalysisContext, RetentionPriority;
-import 'package:analyzer/src/generated/java_engine.dart';
+import 'package:analyzer/exception/exception.dart';
+import 'package:analyzer/file_system/file_system.dart';
+import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_collection.dart';
 import 'package:analyzer/src/task/model.dart';
 import 'package:analyzer/task/model.dart';
 
 /**
+ * The cache results visiting function type.
+ */
+typedef void CacheResultVisitor(AnalysisTarget target, ResultData data);
+
+/**
+ * Return `true` if the [result] of the [target] should be flushed.
+ */
+typedef bool FlushResultFilter<V>(
+    AnalysisTarget target, ResultDescriptor<V> result);
+
+/**
  * Return `true` if the given [target] is a priority one.
  */
 typedef bool IsPriorityAnalysisTarget(AnalysisTarget target);
 
 /**
  * An LRU cache of results produced by analysis.
  */
 class AnalysisCache {
   /**
    * A flag used to control whether trace information should be produced when
    * the content of the cache is modified.
    */
   static bool _TRACE_CHANGES = false;
 
   /**
    * An array containing the partitions of which this cache is comprised.
    */
   final List<CachePartition> _partitions;
 
   /**
    * The [StreamController] reporting [InvalidatedResult]s.
    */
   final ReentrantSynchronousStream<InvalidatedResult> onResultInvalidated =
       new ReentrantSynchronousStream<InvalidatedResult>();
 
+  final List<ReentrantSynchronousStreamSubscription>
+      onResultInvalidatedPartitionSubscriptions =
+      <ReentrantSynchronousStreamSubscription>[];
+
   /**
-   * Initialize a newly created cache to have the given [partitions]. The
+   * Initialize a newly created cache to have the given [_partitions]. The
    * partitions will be searched in the order in which they appear in the array,
    * so the most specific partition (usually an [SdkCachePartition]) should be
    * first and the most general (usually a [UniversalCachePartition]) last.
    */
   AnalysisCache(this._partitions) {
     for (CachePartition partition in _partitions) {
-      partition.onResultInvalidated.listen((InvalidatedResult event) {
+      partition.containingCaches.add(this);
+      ReentrantSynchronousStreamSubscription<InvalidatedResult> subscription =
+          partition.onResultInvalidated.listen((InvalidatedResult event) {
         onResultInvalidated.add(event);
       });
+      onResultInvalidatedPartitionSubscriptions.add(subscription);
     }
   }
 
+  /**
+   * Return an iterator returning all of the [Source] targets.
+   */
+  Iterable<Source> get sources {
+    return _partitions
+        .map((CachePartition partition) => partition.sources)
+        .expand((Iterable<Source> sources) => sources);
+  }
+
   // TODO(brianwilkerson) Implement or delete this.
 //  /**
 //   * Return information about each of the partitions in this cache.
 //   */
 //  List<AnalysisContextStatistics_PartitionData> get partitionData {
 //    int count = _partitions.length;
 //    List<AnalysisContextStatistics_PartitionData> data =
 //        new List<AnalysisContextStatistics_PartitionData>(count);
 //    for (int i = 0; i < count; i++) {
 //      CachePartition partition = _partitions[i];
 //      data[i] = new AnalysisContextStatisticsImpl_PartitionDataImpl(
 //          partition.astSize,
 //          partition.map.length);
 //    }
 //    return data;
 //  }
 
   /**
-   * Return an iterator returning all of the [Source] targets.
+   * Free any allocated resources and references.
    */
-  Iterable<Source> get sources {
-    return _partitions
-        .map((CachePartition partition) => partition._sources)
-        .expand((Iterable<Source> sources) => sources);
+  void dispose() {
+    for (ReentrantSynchronousStreamSubscription subscription
+        in onResultInvalidatedPartitionSubscriptions) {
+      subscription.cancel();
+    }
+    for (CachePartition partition in _partitions) {
+      partition.containingCaches.remove(this);
+    }
   }
 
   /**
+   * Flush results that satisfy the given [filter].
+   */
+  void flush(FlushResultFilter filter) {
+    for (CachePartition partition in _partitions) {
+      partition.flush(filter);
+    }
+  }
+
+  /**
    * Return the entry associated with the given [target].
    */
   CacheEntry get(AnalysisTarget target) {
     int count = _partitions.length;
     for (int i = 0; i < count; i++) {
       CachePartition partition = _partitions[i];
       if (partition.isResponsibleFor(target)) {
         return partition.get(target);
       }
     }
@@ skipping 54 matching lines @@
     }
     return entry.getState(result);
   }
 
   /**
    * Return the value of the given [result] for the given [target].
    *
    * It does not update the cache, if the corresponding [CacheEntry] does not
    * exist, then the default value is returned.
    */
-  Object getValue(AnalysisTarget target, ResultDescriptor result) {
+  Object/*=V*/ getValue/*<V>*/(
+      AnalysisTarget target, ResultDescriptor/*<V>*/ result) {
     CacheEntry entry = get(target);
     if (entry == null) {
       return result.defaultValue;
     }
     return entry.getValue(result);
   }
 
   /**
    * Return an iterator returning all of the map entries mapping targets to
    * cache entries. If the [context] is not `null`, then only entries that are
    * owned by the given context will be returned.
    */
   MapIterator<AnalysisTarget, CacheEntry> iterator(
       {InternalAnalysisContext context: null}) {
     List<Map<AnalysisTarget, CacheEntry>> maps =
         <Map<AnalysisTarget, CacheEntry>>[];
     for (CachePartition partition in _partitions) {
       if (context == null || partition.context == context) {
-        maps.add(partition.map);
+        maps.add(partition.entryMap);
       }
     }
     return new MultipleMapIterator<AnalysisTarget, CacheEntry>(maps);
   }
 
   /**
    * Puts the given [entry] into the cache.
    */
   void put(CacheEntry entry) {
     AnalysisTarget target = entry.target;
@@ skipping 28 matching lines @@
    */
   CacheEntry remove(AnalysisTarget target) {
     int count = _partitions.length;
     for (int i = 0; i < count; i++) {
       CachePartition partition = _partitions[i];
       if (partition.isResponsibleFor(target)) {
         if (_TRACE_CHANGES) {
           AnalysisEngine.instance.logger
               .logInformation('Removed the cache entry for $target.');
         }
-        return partition.remove(target);
+        CacheEntry entry = partition.remove(target);
+        if (entry != null) {
+          entry.dispose();
+        }
+        return entry;
       }
     }
     return null;
   }
 
   /**
    * Return the number of targets that are mapped to cache entries.
    */
   int size() {
     int size = 0;
@@ skipping 10 matching lines @@
  */
 class CacheEntry {
   /**
    * The index of the flag indicating whether the source was explicitly added to
    * the context or whether the source was implicitly added because it was
    * referenced by another source.
    */
   static int _EXPLICITLY_ADDED_FLAG = 0;
 
   /**
-   * The next invalidation process identifier.
+   * The next visit process identifier.
    */
-  static int nextInvalidateId = 0;
+  static int nextVisitId = 0;
+
+  /**
+   * A table containing the number of times the value of a result descriptor was
+   * recomputed after having been flushed.
+   */
+  static final Map<ResultDescriptor, int> recomputedCounts =
+      new HashMap<ResultDescriptor, int>();
 
   /**
    * The target this entry is about.
    */
   final AnalysisTarget target;
 
   /**
    * The partition that is responsible for this entry.
    */
   CachePartition _partition;
@@ skipping 47 matching lines @@
   /**
    * Return a list of result descriptors for results whose state is not
    * [CacheState.INVALID].
    */
   List<ResultDescriptor> get nonInvalidResults => _resultMap.keys.toList();
 
   /**
    * Notifies the entry that the client is going to stop using it.
    */
   void dispose() {
-    _resultMap.forEach((descriptor, data) {
+    _resultMap.forEach((ResultDescriptor descriptor, ResultData data) {
       TargetedResult result = new TargetedResult(target, descriptor);
       for (TargetedResult dependedOnResult in data.dependedOnResults) {
-        ResultData dependedOnData = _partition._getDataFor(dependedOnResult);
-        if (dependedOnData != null) {
-          dependedOnData.dependentResults.remove(result);
+        for (AnalysisCache cache in _partition.containingCaches) {
+          CacheEntry entry = cache.get(dependedOnResult.target);
+          if (entry != null) {
+            ResultData data =
+                entry.getResultDataOrNull(dependedOnResult.result);
+            if (data != null) {
+              data.dependentResults.remove(result);
+            }
+          }
         }
       }
     });
     _resultMap.clear();
   }
 
   /**
    * Fix the state of the [exception] to match the current state of the entry.
    */
   void fixExceptionState() {
     if (!hasErrorState()) {
       _exception = null;
     }
   }
 
   /**
-   * Look up the [ResultData] of [descriptor], or add a new one if it isn't
-   * there.
+   * Flush results that satisfy the given [filter].
+   */
+  void flush(FlushResultFilter filter) {
+    _resultMap.forEach((ResultDescriptor result, ResultData data) {
+      if (filter(target, result)) {
+        data.flush();
+      }
+    });
+  }
+
+  /**
+   * Return the result data associated with the [descriptor], creating one if it
+   * isn't there.
    */
   ResultData getResultData(ResultDescriptor descriptor) {
     return _resultMap.putIfAbsent(descriptor, () => new ResultData(descriptor));
   }
 
   /**
+   * Return the result data associated with the [descriptor], or `null` if there
+   * is no data currently associated with the descriptor.
+   */
+  ResultData getResultDataOrNull(ResultDescriptor descriptor) =>
+      _resultMap[descriptor];
+
+  /**
    * Return the state of the result represented by the given [descriptor].
    */
   CacheState getState(ResultDescriptor descriptor) {
     ResultData data = _resultMap[descriptor];
     if (data == null) {
       return CacheState.INVALID;
     }
     return data.state;
   }
 
   /**
    * Return the value of the result represented by the given [descriptor], or
    * the default value for the result if this entry does not have a valid value.
    */
-  /*<V>*/ dynamic /*V*/ getValue(ResultDescriptor /*<V>*/ descriptor) {
+  dynamic/*=V*/ getValue/*<V>*/(ResultDescriptor/*<V>*/ descriptor) {
     ResultData data = _resultMap[descriptor];
     if (data == null) {
       return descriptor.defaultValue;
     }
     if (_partition != null) {
       _partition.resultAccessed(target, descriptor);
     }
-    return data.value;
+    return data.value as Object/*=V*/;
   }
 
   /**
    * Return `true` if the state of any data value is [CacheState.ERROR].
    */
   bool hasErrorState() {
     for (ResultData data in _resultMap.values) {
       if (data.state == CacheState.ERROR) {
         return true;
       }
@@ skipping 50 matching lines @@
     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(nextInvalidateId++, descriptor, delta, 0);
+        bool canUseDelta =
+            _gatherResultsInvalidatedByDelta(descriptor, delta, 0);
+        if (!canUseDelta) {
+          delta = null;
+        }
+        _invalidate(nextVisitId++, descriptor, delta, 0);
       }
     } 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;
       }
     }
   }
 
   /**
    * Set the value of the result represented by the given [descriptor] to the
    * given [value].
    */
-  /*<V>*/ void setValue(
-      ResultDescriptor /*<V>*/ descriptor,
-      dynamic /*V*/
-      value,
+  void setValue/*<V>*/(ResultDescriptor/*<V>*/ descriptor, dynamic/*=V*/ value,
       List<TargetedResult> dependedOn) {
 //    {
 //      String valueStr = '$value';
 //      if (valueStr.length > 20) {
 //        valueStr = valueStr.substring(0, 20) + '...';
 //      }
 //      valueStr = valueStr.replaceAll('\n', '\\n');
 //      print(
-//          'setValue $descriptor for $target value=$valueStr deps=$dependedOn');
+//          'setValue $descriptor for $target value=$valueStr dependedOn=$dependedOn');
 //    }
     _validateStateChange(descriptor, CacheState.VALID);
     TargetedResult thisResult = new TargetedResult(target, descriptor);
     if (_partition != null) {
       _partition.resultStored(thisResult, value);
     }
     ResultData data = getResultData(descriptor);
     _setDependedOnResults(data, thisResult, dependedOn);
+    if (data.state == CacheState.FLUSHED) {
+      int count = recomputedCounts[descriptor] ?? 0;
+      recomputedCounts[descriptor] = count + 1;
+    }
     data.state = CacheState.VALID;
-    data.value = value == null ? descriptor.defaultValue : value;
+    data.value = value ?? descriptor.defaultValue;
   }
 
   /**
-   * Set the value of the result represented by the given [descriptor] to the
-   * given [value], keep its dependency, invalidate all the dependent result.
+   * If the result represented by the given [descriptor] is valid, set
+   * it to the given [value], keep its dependency, and if [invalidateDependent]
+   * invalidate all the dependent result.
    */
   void setValueIncremental(
       ResultDescriptor descriptor, dynamic value, bool invalidateDependent) {
     ResultData data = getResultData(descriptor);
-    data.state = CacheState.VALID;
-    data.value = value;
+    if (data.state == CacheState.VALID || data.state == CacheState.FLUSHED) {
+      data.value = value;
+    }
     if (invalidateDependent) {
-      _invalidateDependentResults(nextInvalidateId++, data, null, 0);
+      _invalidateDependentResults(nextVisitId++, data, null, 0);
     }
   }
 
   @override
   String toString() {
     StringBuffer buffer = new StringBuffer();
     _writeOn(buffer);
     return buffer.toString();
   }
 
   /**
+   * Visit the given [result] and all results that depend on it, and
+   * ask [delta] to gather changes. Return `true` if the [delta] can be used
+   * to perform limited invalidation, or `false` if the changes collection
+   * process does not stop (should not happen).
+   */
+  bool _gatherResultsInvalidatedByDelta(
+      ResultDescriptor result, Delta delta, int level) {
+    if (delta == null) {
+      return false;
+    }
+    if (!delta.shouldGatherChanges) {
+      return true;
+    }
+    for (int i = 0; i < 64; i++) {
+      bool hasVisitChanges = false;
+      _visitResults(nextVisitId++, result,
+          (AnalysisTarget target, ResultData data) {
+        bool hasDeltaChanges = delta.gatherChanges(
+            _partition.context, target, data.descriptor, data.value);
+        if (hasDeltaChanges) {
+          hasVisitChanges = true;
+        }
+      });
+      delta.gatherEnd();
+      if (!hasVisitChanges) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
    * 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(
       int id, ResultDescriptor descriptor, Delta delta, int level) {
     ResultData thisData = _resultMap[descriptor];
     if (thisData == null) {
       return;
     }
     // Stop if already validated.
     if (delta != null) {
-      if (thisData.invalidateId == id) {
+      if (thisData.visitId == id) {
         return;
       }
-      thisData.invalidateId = id;
+      thisData.visitId = id;
     }
     // Ask the delta to validate.
     DeltaResult deltaResult = null;
     if (delta != null) {
-      deltaResult = delta.validate(_partition.context, target, descriptor);
+      deltaResult = delta.validate(
+          _partition.context, target, descriptor, thisData.value);
       if (deltaResult == DeltaResult.STOP) {
         return;
       }
     }
+//    if (deltaResult != null) {
+//      String indent = '  ' * level;
+//      String deltaResultName = deltaResult.toString().split('.').last;
+//      print('[$id]$indent$deltaResultName $descriptor for $target');
+//    }
     if (deltaResult == DeltaResult.INVALIDATE_NO_DELTA) {
       delta = null;
     }
-    if (deltaResult == null ||
+    if (deltaResult == DeltaResult.INVALIDATE_KEEP_DEPENDENCIES) {
+      thisData.value = descriptor.defaultValue;
+      thisData.state = CacheState.INVALID;
+    } else if (deltaResult == null ||
         deltaResult == DeltaResult.INVALIDATE ||
         deltaResult == DeltaResult.INVALIDATE_NO_DELTA) {
       _resultMap.remove(descriptor);
-//      {
+      // Stop depending on other results.
+      {
+        TargetedResult thisResult = new TargetedResult(target, descriptor);
+        List<AnalysisCache> caches = _partition.containingCaches;
+        int cacheLength = caches.length;
+        List<TargetedResult> results = thisData.dependedOnResults;
+        int resultLength = results.length;
+        for (int i = 0; i < resultLength; i++) {
+          TargetedResult dependedOnResult = results[i];
+          for (int j = 0; j < cacheLength; j++) {
+            AnalysisCache cache = caches[j];
+            CacheEntry entry = cache.get(dependedOnResult.target);
+            if (entry != null) {
+              ResultData data =
+                  entry.getResultDataOrNull(dependedOnResult.result);
+              if (data != null) {
+                data.dependentResults.remove(thisResult);
+              }
+            }
+          }
+        }
+      }
+//      if (deltaResult == null) {
 //        String indent = '  ' * level;
 //        print('[$id]$indent invalidate $descriptor for $target');
 //      }
     }
-    // Stop depending on other results.
-    TargetedResult thisResult = new TargetedResult(target, descriptor);
-    for (TargetedResult dependedOnResult in thisData.dependedOnResults) {
-      ResultData data = _partition._getDataFor(dependedOnResult);
-      if (data != null && deltaResult != DeltaResult.KEEP_CONTINUE) {
-        data.dependentResults.remove(thisResult);
-      }
-    }
     // Invalidate results that depend on this result.
     _invalidateDependentResults(id, thisData, delta, level + 1);
-    // If empty, remove the entry altogether.
-    if (_resultMap.isEmpty) {
-      _partition._targetMap.remove(target);
+    // If empty and not explicitly added, remove the entry altogether.
+    if (_resultMap.isEmpty && !explicitlyAdded) {
+      CacheEntry entry = _partition.entryMap.remove(target);
+      if (entry != null) {
+        entry.dispose();
+      }
       _partition._removeIfSource(target);
     }
     // Notify controller.
-    _partition.onResultInvalidated
-        .add(new InvalidatedResult(this, descriptor, thisData.value));
+    if (deltaResult != DeltaResult.KEEP_CONTINUE) {
+      _partition.onResultInvalidated
+          .add(new InvalidatedResult(this, descriptor, thisData.value));
+    }
   }
 
   /**
    * Invalidates all the results of this entry, with propagation.
    */
   void _invalidateAll() {
     List<ResultDescriptor> results = _resultMap.keys.toList();
-    for (ResultDescriptor result in results) {
-      _invalidate(nextInvalidateId++, result, null, 0);
+    int length = results.length;
+    for (int i = 0; i < length; i++) {
+      ResultDescriptor result = results[i];
+      _invalidate(nextVisitId++, result, null, 0);
     }
   }
 
   /**
    * Invalidate results that depend on [thisData].
    */
   void _invalidateDependentResults(
       int id, ResultData thisData, Delta delta, int level) {
+    // It is necessary to copy the results to a list to avoid a concurrent
+    // modification of the set of dependent results.
+    List<AnalysisCache> caches = _partition.containingCaches;
+    int cacheLength = caches.length;
     List<TargetedResult> dependentResults = thisData.dependentResults.toList();
-    for (TargetedResult dependentResult in dependentResults) {
-      CacheEntry entry = _partition.get(dependentResult.target);
-      if (entry != null) {
-        entry._invalidate(id, dependentResult.result, delta, level);
+    int resultLength = dependentResults.length;
+    for (int i = 0; i < resultLength; i++) {
+      TargetedResult dependentResult = dependentResults[i];
+      for (int j = 0; j < cacheLength; j++) {
+        AnalysisCache cache = caches[j];
+        CacheEntry entry = cache.get(dependentResult.target);
+        if (entry != null) {
+          entry._invalidate(id, dependentResult.result, delta, level);
+        }
       }
     }
   }
 
   /**
    * 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);
-      if (data != null) {
-        data.dependentResults.remove(thisResult);
+    List<AnalysisCache> caches = _partition.containingCaches;
+    int cacheLength = caches.length;
+
+    List<TargetedResult> oldResults = thisData.dependedOnResults;
+    int oldLength = oldResults.length;
+    for (int i = 0; i < oldLength; i++) {
+      TargetedResult dependedOnResult = oldResults[i];
+      for (int j = 0; j < cacheLength; j++) {
+        AnalysisCache cache = caches[j];
+        CacheEntry entry = cache.get(dependedOnResult.target);
+        if (entry != null) {
+          ResultData data = entry.getResultDataOrNull(dependedOnResult.result);
+          if (data != null) {
+            data.dependentResults.remove(thisResult);
+          }
+        }
       }
-    });
+    }
     thisData.dependedOnResults = dependedOn;
-    thisData.dependedOnResults.forEach((TargetedResult dependedOnResult) {
-      ResultData data = _partition._getDataFor(dependedOnResult);
-      if (data != null) {
-        data.dependentResults.add(thisResult);
+    int newLength = dependedOn.length;
+    for (int i = 0; i < newLength; i++) {
+      TargetedResult dependedOnResult = dependedOn[i];
+      for (int j = 0; j < cacheLength; j++) {
+        AnalysisCache cache = caches[j];
+        CacheEntry entry = cache.get(dependedOnResult.target);
+        if (entry != null) {
+          ResultData data = entry.getResultData(dependedOnResult.result);
+          data.dependentResults.add(thisResult);
+        }
       }
-    });
+    }
   }
 
   /**
    * Set states of the given and dependent results to [CacheState.ERROR] and
    * their values to the corresponding default values
    */
   void _setErrorState(ResultDescriptor descriptor, CaughtException exception) {
     ResultData thisData = getResultData(descriptor);
     // Set the error state.
     _exception = exception;
     thisData.state = CacheState.ERROR;
     thisData.value = descriptor.defaultValue;
     // Propagate the error state.
+    List<AnalysisCache> caches = _partition.containingCaches;
+    int cacheLength = caches.length;
     thisData.dependentResults.forEach((TargetedResult dependentResult) {
-      CacheEntry entry = _partition.get(dependentResult.target);
-      entry._setErrorState(dependentResult.result, exception);
+      for (int i = 0; i < cacheLength; i++) {
+        AnalysisCache cache = caches[i];
+        CacheEntry entry = cache.get(dependentResult.target);
+        if (entry != null) {
+          entry._setErrorState(dependentResult.result, exception);
+        }
+      }
     });
   }
 
   /**
    * Set the value of the flag with the given [index] to the given [value].
    */
   void _setFlag(int index, bool value) {
     _flags = BooleanArray.set(_flags, index, value);
   }
 
@@ skipping 14 matching lines @@
 //      InstrumentationBuilder builder =
 //          Instrumentation.builder2('CacheEntry-validateStateChange');
 //      builder.data3('message', message);
 //      //builder.data('source', source.getFullName());
 //      builder.record(new CaughtException(new AnalysisException(message), null));
 //      builder.log();
 //    }
   }
 
   /**
+   * Call [visitor] for the result described by the given [descriptor] and all
+   * results that depend on directly or indirectly. Each result is visited
+   * only once.
+   */
+  void _visitResults(
+      int id, ResultDescriptor descriptor, CacheResultVisitor visitor) {
+    ResultData thisData = _resultMap[descriptor];
+    if (thisData == null) {
+      return;
+    }
+    // Stop if already visited.
+    if (thisData.visitId == id) {
+      return;
+    }
+    thisData.visitId = id;
+    // Visit this result.
+    visitor(target, thisData);
+    // Visit results that depend on this result.
+    List<AnalysisCache> caches = _partition.containingCaches;
+    int cacheLength = caches.length;
+    List<TargetedResult> dependentResults = thisData.dependentResults.toList();
+    int resultLength = dependentResults.length;
+    for (int i = 0; i < resultLength; i++) {
+      TargetedResult dependentResult = dependentResults[i];
+      for (int j = 0; j < cacheLength; j++) {
+        AnalysisCache cache = caches[j];
+        CacheEntry entry = cache.get(dependentResult.target);
+        if (entry != null) {
+          entry._visitResults(id, dependentResult.result, visitor);
+        }
+      }
+    }
+  }
+
+  /**
    * Write a textual representation of this entry to the given [buffer]. The
    * result should only be used for debugging purposes.
    */
   void _writeOn(StringBuffer buffer) {
     buffer.write('time = ');
     buffer.write(modificationTime);
     List<ResultDescriptor> results = _resultMap.keys.toList();
     results.sort((ResultDescriptor first, ResultDescriptor second) =>
         first.toString().compareTo(second.toString()));
     for (ResultDescriptor result in results) {
@@ skipping 38 matching lines @@
   /**
    * The current maximum cache size.
    */
   int maxSize;
 
   CacheFlushManager(
       ResultCachingPolicy<T> policy, this.isPriorityAnalysisTarget)
       : policy = policy,
         maxActiveSize = policy.maxActiveSize,
         maxIdleSize = policy.maxIdleSize,
-        maxSize = policy.maxIdleSize;
+        maxSize = policy.maxActiveSize;
 
   /**
    * If [currentSize] is already less than [maxSize], returns an empty list.
    * Otherwise returns [TargetedResult]s to flush from the cache to make
    * [currentSize] less or equal to [maxSize].
    *
    * Results for priority files are never flushed, so this method might leave
    * [currentSize] greater than [maxSize].
    */
   List<TargetedResult> flushToSize() {
@@ skipping 79 matching lines @@
  * A single partition in an LRU cache of information related to analysis.
  */
 abstract class CachePartition {
   /**
    * The context that owns this partition. Multiple contexts can reference a
    * partition, but only one context can own it.
    */
   final InternalAnalysisContext context;
 
   /**
+   * A list of the caches that contain this partition. This includes the cache
+   * associated with the context that owns this partition.
+   */
+  final List<AnalysisCache> containingCaches = <AnalysisCache>[];
+
+  /**
    * A table mapping caching policies to the cache flush managers.
    */
   final HashMap<ResultCachingPolicy, CacheFlushManager> _flushManagerMap =
       new HashMap<ResultCachingPolicy, CacheFlushManager>();
 
   /**
    * The [StreamController] reporting [InvalidatedResult]s.
    */
   final ReentrantSynchronousStream<InvalidatedResult> onResultInvalidated =
       new ReentrantSynchronousStream<InvalidatedResult>();
 
   /**
    * A table mapping the targets belonging to this partition to the information
    * known about those targets.
    */
-  HashMap<AnalysisTarget, CacheEntry> _targetMap =
+  final HashMap<AnalysisTarget, CacheEntry> entryMap =
       new HashMap<AnalysisTarget, CacheEntry>();
 
   /**
    * A set of the [Source] targets.
    */
-  final HashSet<Source> _sources = new HashSet<Source>();
+  final HashSet<Source> sources = new HashSet<Source>();
 
   /**
    * A table mapping full paths to lists of [Source]s with these full paths.
    */
-  final Map<String, List<Source>> _pathToSources = <String, List<Source>>{};
+  final Map<String, List<Source>> pathToSource = <String, List<Source>>{};
 
   /**
    * Initialize a newly created cache partition, belonging to the given
    * [context].
    */
   CachePartition(this.context);
 
   /**
-   * Return a table mapping the targets known to the context to the information
-   * known about the target.
-   *
-   * <b>Note:</b> This method is only visible for use by [AnalysisCache] and
-   * should not be used for any other purpose.
+   * Specify whether a context that uses this partition is being analyzed.
    */
-  Map<AnalysisTarget, CacheEntry> get map => _targetMap;
+  set isActive(bool active) {
+    for (CacheFlushManager manager in _flushManagerMap.values) {
+      if (active) {
+        manager.madeActive();
+      } else {
+        List<TargetedResult> resultsToFlush = manager.madeIdle();
+        _flushResults(resultsToFlush);
+      }
+    }
+  }
 
   /**
    * Notifies the partition that the client is going to stop using it.
    */
   void dispose() {
-    for (CacheEntry entry in _targetMap.values) {
+    for (CacheEntry entry in entryMap.values) {
       entry.dispose();
     }
-    _targetMap.clear();
+    entryMap.clear();
+    sources.clear();
+    pathToSource.clear();
+  }
+
+  /**
+   * Flush results that satisfy the given [filter].
+   */
+  void flush(FlushResultFilter filter) {
+    for (CacheEntry entry in entryMap.values) {
+      entry.flush(filter);
+    }
   }
 
   /**
    * Return the entry associated with the given [target].
    */
-  CacheEntry get(AnalysisTarget target) => _targetMap[target];
+  CacheEntry get(AnalysisTarget target) => entryMap[target];
 
   /**
    * Return [Source]s whose full path is equal to the given [path].
    * Maybe empty, but not `null`.
    */
   List<Source> getSourcesWithFullName(String path) {
-    List<Source> sources = _pathToSources[path];
-    return sources != null ? sources : Source.EMPTY_LIST;
+    List<Source> sources = pathToSource[path];
+    return sources ?? Source.EMPTY_LIST;
   }
 
   /**
    * Return `true` if this partition is responsible for the given [target].
    */
   bool isResponsibleFor(AnalysisTarget target);
 
   /**
    * Return an iterator returning all of the map entries mapping targets to
    * cache entries.
    */
   MapIterator<AnalysisTarget, CacheEntry> iterator() =>
-      new SingleMapIterator<AnalysisTarget, CacheEntry>(_targetMap);
+      new SingleMapIterator<AnalysisTarget, CacheEntry>(entryMap);
 
   /**
    * Puts the given [entry] into the partition.
    */
   void put(CacheEntry entry) {
     AnalysisTarget target = entry.target;
     if (entry._partition != null) {
       throw new StateError(
           'The entry for $target is already in ${entry._partition}');
     }
     entry._partition = this;
     entry.fixExceptionState();
-    _targetMap[target] = entry;
+    entryMap[target] = entry;
     _addIfSource(target);
   }
 
   /**
    * Remove all information related to the given [target] from this partition.
    * Return the entry associated with the target, or `null` if there was cache
    * entry for the target.
    */
   CacheEntry remove(AnalysisTarget target) {
     for (CacheFlushManager flushManager in _flushManagerMap.values) {
       flushManager.targetRemoved(target);
     }
-    CacheEntry entry = _targetMap.remove(target);
+    CacheEntry entry = entryMap.remove(target);
     if (entry != null) {
       entry._invalidateAll();
     }
     _removeIfSource(target);
     return entry;
   }
 
   /**
    * Records that a value of the result described by the given [descriptor]
    * for the given [target] was just read from the cache.
    */
   void resultAccessed(AnalysisTarget target, ResultDescriptor descriptor) {
     CacheFlushManager flushManager = _getFlushManager(descriptor);
     TargetedResult result = new TargetedResult(target, descriptor);
     flushManager.resultAccessed(result);
   }
 
   /**
    * Records that the given [result] was just stored into the cache.
    */
   void resultStored(TargetedResult result, Object value) {
     CacheFlushManager flushManager = _getFlushManager(result.result);
     List<TargetedResult> resultsToFlush =
         flushManager.resultStored(result, value);
+    _flushResults(resultsToFlush);
+  }
+
+  /**
+   * Return the number of targets that are mapped to cache entries.
+   */
+  int size() => entryMap.length;
+
+  /**
+   * If the given [target] is a [Source], adds it to [sources].
+   */
+  void _addIfSource(AnalysisTarget target) {
+    if (target is Source) {
+      sources.add(target);
+      String fullName = target.fullName;
+      pathToSource.putIfAbsent(fullName, () => <Source>[]).add(target);
+    }
+  }
+
+  /**
+   * Flush the given [resultsToFlush].
+   */
+  void _flushResults(List<TargetedResult> resultsToFlush) {
     for (TargetedResult result in resultsToFlush) {
       CacheEntry entry = get(result.target);
       if (entry != null) {
         ResultData data = entry._resultMap[result.result];
         if (data != null) {
           data.flush();
         }
       }
     }
   }
 
   /**
-   * Return the number of targets that are mapped to cache entries.
-   */
-  int size() => _targetMap.length;
-
-  /**
-   * If the given [target] is a [Source], adds it to [_sources].
-   */
-  void _addIfSource(AnalysisTarget target) {
-    if (target is Source) {
-      _sources.add(target);
-      String fullName = target.fullName;
-      _pathToSources.putIfAbsent(fullName, () => <Source>[]).add(target);
-    }
-  }
-
-  ResultData _getDataFor(TargetedResult result) {
-    CacheEntry entry = context.analysisCache.get(result.target);
-    return entry != null ? entry._resultMap[result.result] : null;
-  }
-
-  /**
    * Return the [CacheFlushManager] for the given [descriptor], not `null`.
    */
   CacheFlushManager _getFlushManager(ResultDescriptor descriptor) {
     ResultCachingPolicy policy = descriptor.cachingPolicy;
-    if (identical(policy, DEFAULT_CACHING_POLICY)) {
+    if (identical(policy, DEFAULT_CACHING_POLICY) ||
+        context.analysisOptions.disableCacheFlushing) {
       return UnlimitedCacheFlushManager.INSTANCE;
     }
     CacheFlushManager manager = _flushManagerMap[policy];
     if (manager == null) {
       manager = new CacheFlushManager(policy, _isPriorityAnalysisTarget);
       _flushManagerMap[policy] = manager;
     }
     return manager;
   }
 
   bool _isPriorityAnalysisTarget(AnalysisTarget target) {
-    return context.priorityTargets.contains(target);
+    Source source = target.source;
+    return source != null && context.prioritySources.contains(source);
   }
 
   /**
-   * If the given [target] is a [Source], remove it from the list of [_sources].
+   * If the given [target] is a [Source], remove it from the list of [sources].
    */
   void _removeIfSource(AnalysisTarget target) {
     if (target is Source) {
-      _sources.remove(target);
-      String fullName = target.fullName;
-      List<Source> sources = _pathToSources[fullName];
-      if (sources != null) {
-        sources.remove(target);
-        if (sources.isEmpty) {
-          _pathToSources.remove(fullName);
+      sources.remove(target);
+      String path = target.fullName;
+      List<Source> pathSources = pathToSource[path];
+      if (pathSources != null) {
+        pathSources.remove(target);
+        if (pathSources.isEmpty) {
+          pathToSource.remove(path);
         }
       }
     }
   }
 }
 
 /**
  * The description for a change.
  */
 class Delta {
   final Source source;
 
   Delta(this.source);
 
   /**
+   * Return `true` if this delta needs cache walking to gather additional
+   * changes before it can be used to [validate].  In this case [gatherChanges]
+   * is invoked for every targeted result in transitive dependencies, and
+   * [gatherEnd] is invoked after cache walking is done.
+   */
+  bool get shouldGatherChanges => false;
+
+  /**
+   * This method is called during a cache walk, so that the delta can gather
+   * additional changes to which are caused by the changes it already knows
+   * about.  Return `true` if a new change was added, so that one more cache
+   * walk will be performed (to include changes that depend on results which we
+   * decided to be changed later in the previous cache walk).
+   */
+  bool gatherChanges(InternalAnalysisContext context, AnalysisTarget target,
+      ResultDescriptor descriptor, Object value) {
+    return false;
+  }
+
+  /**
+   * The current cache results visit is done.
+   */
+  void gatherEnd() {}
+
+  /**
    * Check whether this delta affects the result described by the given
-   * [descriptor] and [target].
+   * [descriptor] and [target]. The current [value] of the result is provided.
    */
   DeltaResult validate(InternalAnalysisContext context, AnalysisTarget target,
-      ResultDescriptor descriptor) {
+      ResultDescriptor descriptor, Object value) {
     return DeltaResult.INVALIDATE;
   }
 }
 
 /**
- * The possible results of validating analysis results againt a [Delta].
+ * The possible results of validating analysis results against a [Delta].
  */
 enum DeltaResult {
   /**
    * Invalidate this result and continue visiting dependent results
-   * with this [Delta].
+   * with this [Delta]. Remove the result and all its dependencies.
    */
   INVALIDATE,
 
   /**
+   * Invalidate this result and continue visiting dependent results
+   * with this [Delta]. Keep the dependencies of this result.
+   */
+  INVALIDATE_KEEP_DEPENDENCIES,
+
+  /**
    * Invalidate this result and stop using this [Delta], so unconditionally
    * invalidate all the dependent results.
    */
   INVALIDATE_NO_DELTA,
 
   /**
    * Keep this result and continue validating dependent results
    * with this [Delta].
    */
   KEEP_CONTINUE,
 
   /**
    * Keep this result and stop visiting results that depend on this one.
    */
   STOP
 }
 
 /**
  * [InvalidatedResult] describes an invalidated result.
  */
-class InvalidatedResult {
+class InvalidatedResult<V> {
   /**
    * The target in which the result was invalidated.
    */
   final CacheEntry entry;
 
   /**
    * The descriptor of the result which was invalidated.
    */
-  final ResultDescriptor descriptor;
+  final ResultDescriptor<V> descriptor;
 
   /**
-   * The value of the result which was invalidated.
+   * The value of the result before it was invalidated, may be the default
+   * value if the result was flushed.
    */
-  final Object value;
+  final V value;
 
   InvalidatedResult(this.entry, this.descriptor, this.value);
 
   @override
   String toString() => '$descriptor of ${entry.target}';
 }
 
 /**
+ * A cache partition that contains all of the targets in a single package.
+ */
+class PackageCachePartition extends CachePartition {
+  /**
+   * The root of the directory representing the package.
+   */
+  final Folder packageRoot;
+
+  /**
+   * Initialize a newly created cache partition, belonging to the given
+   * [context].
+   */
+  PackageCachePartition(InternalAnalysisContext context, this.packageRoot)
+      : super(context);
+
+  @override
+  bool isResponsibleFor(AnalysisTarget target) {
+    Source source = target.source;
+    return source != null && packageRoot.contains(source.fullName);
+  }
+}
+
+/**
  * A Stream-like interface, which broadcasts events synchronously.
  * If a second event is fired while delivering a first event, then the second
  * event will be delivered first, and then delivering of the first will be
  * continued.
  */
 class ReentrantSynchronousStream<T> {
   final List<Function> listeners = <Function>[];
 
   /**
    * Send the given [event] to the stream.
    */
   void add(T event) {
     List<Function> listeners = this.listeners.toList();
     for (Function listener in listeners) {
       listener(event);
     }
   }
 
   /**
    * Listen for the events in this stream.
    * Note that if the [listener] fires a new event, then the [listener] will be
    * invoked again before returning from the [add] invocation.
    */
-  void listen(void listener(T event)) {
+  ReentrantSynchronousStreamSubscription<T> listen(void listener(T event)) {
     listeners.add(listener);
+    return new ReentrantSynchronousStreamSubscription<T>(this, listener);
   }
 }
 
+/**
+ * A subscription on events from a [ReentrantSynchronousStream].
+ */
+class ReentrantSynchronousStreamSubscription<T> {
+  final ReentrantSynchronousStream<T> _stream;
+  final Function _listener;
+
+  ReentrantSynchronousStreamSubscription(this._stream, this._listener);
+
+  /**
+   * Cancels this subscription.
+   * It will no longer receive events.
+   */
+  void cancel() {
+    _stream.listeners.remove(_listener);
+  }
+}
+
 /**
  * The data about a single analysis result that is stored in a [CacheEntry].
  */
 // TODO(brianwilkerson) Consider making this a generic class so that the value
 // can be typed.
 class ResultData {
   /**
    * The [ResultDescriptor] this result is for.
    */
   final ResultDescriptor descriptor;
 
   /**
    * The state of the cached value.
    */
   CacheState state;
 
   /**
    * The value being cached, or the default value for the result if there is no
    * value (for example, when the [state] is [CacheState.INVALID]).
    */
   Object value;
 
   /**
-   * The identifier of the invalidation process that most recently checked
-   * this value. If it is the same as the current invalidation identifier,
-   * then there is no reason to check it (and its subtree again).
+   * The identifier of the most recent visiting process. We use it to visit
+   * every result only once.
    */
-  int invalidateId = -1;
+  int visitId = -1;
 
   /**
    * A list of the results on which this result depends.
    */
   List<TargetedResult> dependedOnResults = <TargetedResult>[];
 
   /**
    * A list of the results that depend on this result.
    */
   Set<TargetedResult> dependentResults = new Set<TargetedResult>();
@@ skipping 62 matching lines @@
   void resultAccessed(TargetedResult result) {}
 
   @override
   List<TargetedResult> resultStored(TargetedResult newResult, newValue) {
     return TargetedResult.EMPTY_LIST;
   }
 
   @override
   void targetRemoved(AnalysisTarget target) {}
 }