Cache flushing implementation for the task model.

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:collection';
 
-import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisEngine, CacheState, InternalAnalysisContext, RetentionPriority;
-import 'package:analyzer/src/generated/html.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_collection.dart';
 import 'package:analyzer/src/generated/utilities_general.dart';
 import 'package:analyzer/task/model.dart';
 
 /**
+ * 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;
 
   /**
    * 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);
-
-  /**
-   * Return the number of entries in this cache that have an AST associated with
-   * them.
-   */
-  int get astSize => _partitions[_partitions.length - 1].astSize;
+  AnalysisCache(this._partitions) {
+    for (CachePartition partition in _partitions) {
+      partition._cache = this;
+    }
+  }
 
   // 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;
 //  }
 
   /**
-   * Record that the AST associated with the given [target] was just read from
-   * the cache.
-   */
-  void accessedAst(AnalysisTarget target) {
-    // TODO(brianwilkerson) Extract this logic to a helper method (here and
-    // elsewhere)
-    int count = _partitions.length;
-    for (int i = 0; i < count; i++) {
-      if (_partitions[i].contains(target)) {
-        _partitions[i].accessedAst(target);
-        return;
-      }
-    }
-  }
-
-  /**
    * Return the entry associated with the given [target].
    */
   CacheEntry get(AnalysisTarget target) {
     int count = _partitions.length;
     for (int i = 0; i < count; i++) {
       if (_partitions[i].contains(target)) {
         return _partitions[i].get(target);
       }
     }
     //
@@ skipping 36 matching lines @@
     for (int i = 0; i < count; i++) {
       maps[i] = _partitions[i].map;
     }
     return new MultipleMapIterator<AnalysisTarget, CacheEntry>(maps);
   }
 
   /**
    * Associate the given [entry] with the given [target].
    */
   void put(AnalysisTarget target, CacheEntry entry) {
-    entry._cache = this;
-    entry._target = target;
     entry.fixExceptionState();
     int count = _partitions.length;
     for (int i = 0; i < count; i++) {
       if (_partitions[i].contains(target)) {
         if (_TRACE_CHANGES) {
           CacheEntry oldEntry = _partitions[i].get(target);
           if (oldEntry == null) {
             AnalysisEngine.instance.logger
                 .logInformation('Added a cache entry for $target.');
           } else {
@@ skipping 21 matching lines @@
           AnalysisEngine.instance.logger
               .logInformation('Removed the cache entry for $target.');
         }
         _partitions[i].remove(target);
         return;
       }
     }
   }
 
   /**
-   * Record that the AST associated with the given [target] was just removed
-   * from the cache.
-   */
-  void removedAst(AnalysisTarget target) {
-    int count = _partitions.length;
-    for (int i = 0; i < count; i++) {
-      if (_partitions[i].contains(target)) {
-        _partitions[i].removedAst(target);
-        return;
-      }
-    }
-  }
-
-  /**
    * Return the number of targets that are mapped to cache entries.
    */
   int size() {
     int size = 0;
     int count = _partitions.length;
     for (int i = 0; i < count; i++) {
       size += _partitions[i].size();
     }
     return size;
   }
 
-  /**
-   * Record that the AST associated with the given [target] was just stored to
-   * the cache.
-   */
-  void storedAst(AnalysisTarget target) {
-    int count = _partitions.length;
-    for (int i = 0; i < count; i++) {
-      if (_partitions[i].contains(target)) {
-        _partitions[i].storedAst(target);
-        return;
-      }
-    }
-  }
-
   ResultData _getDataFor(TargetedResult result) {
     AnalysisTarget target = result.target;
     int count = _partitions.length;
     for (int i = 0; i < count; i++) {
       if (_partitions[i].contains(target)) {
         CacheEntry entry = _partitions[i].get(target);
         return entry._getResultData(result.result);
       }
     }
     return null;
   }
 }
 
 /**
  * The information cached by an analysis context about an individual target.
  */
 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 cache that contains this entry.
+   * The partition that is responsible for this entry.
    */
-  AnalysisCache _cache;
+  CachePartition _partition;
 
   /**
    * The target this entry is about.
    */
   AnalysisTarget _target;
 
   /**
    * The most recent time at which the state of the target matched the state
    * represented by this entry.
    */
@@ skipping 31 matching lines @@
 
   /**
    * Set whether the source was explicitly added to the context to match the
    * [explicitlyAdded] flag.
    */
   void set explicitlyAdded(bool explicitlyAdded) {
     _setFlag(_EXPLICITLY_ADDED_FLAG, explicitlyAdded);
   }
 
   /**
-   * Return `true` if this entry contains at least one result whose value is an
-   * AST structure.
-   */
-  bool get hasAstStructure {
-    for (ResultData data in _resultMap.values) {
-      if (data.value is AstNode || data.value is XmlNode) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  /**
    * Fix the state of the [exception] to match the current state of the entry.
    */
   void fixExceptionState() {
     if (!hasErrorState()) {
       _exception = null;
     }
   }
 
   /**
-   * Mark any AST structures associated with this cache entry as being flushed.
-   */
-  void flushAstStructures() {
-    _resultMap.forEach((ResultDescriptor descriptor, ResultData data) {
-      if (data.value is AstNode || data.value is XmlNode) {
-        _validateStateChange(descriptor, CacheState.FLUSHED);
-        data.state = CacheState.FLUSHED;
-        data.value = descriptor.defaultValue;
-      }
-    });
-  }
-
-  /**
    * Return the memento of the result represented by the given [descriptor].
    */
   Object getMemento(ResultDescriptor descriptor) {
     ResultData data = _resultMap[descriptor];
     if (data == null) {
       return null;
     }
     return data.memento;
   }
 
@@ skipping 10 matching lines @@
 
   /**
    * 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) {
     ResultData data = _resultMap[descriptor];
     if (data == null) {
       return descriptor.defaultValue;
     }
+    if (_partition != null) {
+      _partition.resultAccessed(_target, descriptor);
+    }
     return data.value;
   }
 
   /**
    * 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 34 matching lines @@
     if (descriptors == null || descriptors.isEmpty) {
       throw new ArgumentError('at least one descriptor is expected');
     }
     if (exception == null) {
       throw new ArgumentError('an exception is expected');
     }
     this._exception = exception;
     for (ResultDescriptor descriptor in descriptors) {
       ResultData data = _getResultData(descriptor);
       TargetedResult thisResult = new TargetedResult(_target, descriptor);
-      data.invalidate(_cache, thisResult, CacheState.ERROR);
+      data.invalidate(_partition, thisResult, CacheState.ERROR);
     }
   }
 
   /**
    * Set the state of the result represented by the given [descriptor] to the
    * given [state].
    */
   void setState(ResultDescriptor descriptor, CacheState state) {
     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) {
         TargetedResult thisResult = new TargetedResult(_target, descriptor);
-        data.invalidate(_cache, thisResult, CacheState.INVALID);
+        data.invalidate(_partition, thisResult, CacheState.INVALID);
       }
     } 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]. The optional [memento] may help to recompute [value] more
    * efficiently after invalidation.
    */
   /*<V>*/ void setValue(ResultDescriptor /*<V>*/ descriptor, dynamic /*V*/
       value, List<TargetedResult> dependedOn, Object memento) {
     _validateStateChange(descriptor, CacheState.VALID);
+    TargetedResult thisResult = new TargetedResult(_target, descriptor);
+    if (_partition != null) {
+      _partition.resultStored(thisResult, value);
+    }
     ResultData data = _getResultData(descriptor);
-    {
-      TargetedResult thisResult = new TargetedResult(_target, descriptor);
-      data.invalidate(_cache, thisResult, CacheState.INVALID);
-      data.setDependedOnResults(_cache, thisResult, dependedOn);
-    }
+    data.invalidate(_partition, thisResult, CacheState.INVALID);
+    data.setDependedOnResults(_partition, thisResult, dependedOn);
     data.state = CacheState.VALID;
     data.value = value == null ? descriptor.defaultValue : value;
     data.memento = memento;
   }
 
   @override
   String toString() {
     StringBuffer buffer = new StringBuffer();
     _writeOn(buffer);
     return buffer.toString();
@@ skipping 56 matching lines @@
       ResultData data = _resultMap[result];
       buffer.write('; ');
       buffer.write(result.toString());
       buffer.write(' = ');
       buffer.write(data.state);
     }
   }
 }
 
 /**
+ * An object that controls flushing of analysis results from the cache.
+ */
+class CacheFlushManager<T> {
+  final IsPriorityAnalysisTarget isPriorityAnalysisTarget;
+  final ResultCachingPolicy<T> policy;
+  final int maxActiveSize;
+  final int maxIdleSize;
+
+  /**
+   * A map of the stored [TargetedResult] to their sizes.
+   */
+  final HashMap<TargetedResult, int> resultSizeMap =
+      new HashMap<TargetedResult, int>();
+
+  /**
+   * A linked set containing the most recently accessed results with the most
+   * recently used at the end of the list. When more results are added than the
+   * maximum size allowed then the least recently used results will be flushed
+   * from the cache.
+   */
+  final LinkedHashSet<TargetedResult> recentlyUsed =
+      new LinkedHashSet<TargetedResult>();
+
+  /**
+   * The current size of stored results.
+   */
+  int currentSize = 0;
+
+  /**
+   * The current maximum cache size.
+   */
+  int maxSize;
+
+  CacheFlushManager(
+      ResultCachingPolicy<T> policy, this.isPriorityAnalysisTarget)
+      : policy = policy,
+        maxActiveSize = policy.maxActiveSize,
+        maxIdleSize = policy.maxIdleSize,
+        maxSize = policy.maxIdleSize;
+
+  /**
+   * If [currentSize] is already less than [maxSize], returns an empty list.
+   * Otherwise returns [TargetedResult]s to flush from the cache to make
+   * [currentSize] lass then [maxSize].

[Brian Wilkerson, 2015/05/07 14:19:19]

"lass then" --> "less than"

If it's intentional that this method might leave currentSize >= maxSize (because
we won't flush priority files), then we should document that fact.

[scheglov, 2015/05/07 15:49:27]

Done.

+   */
+  List<TargetedResult> flushToSize() {
+    // If still under the cap, done.
+    if (maxSize == -1 || currentSize <= maxSize) {
+      return TargetedResult.EMPTY_LIST;
+    }
+    // Flush results until we are under the cap.
+    List<TargetedResult> resultsToFlush = <TargetedResult>[];
+    for (TargetedResult result in recentlyUsed) {
+      if (isPriorityAnalysisTarget(result.target)) {
+        continue;
+      }
+      resultsToFlush.add(result);
+      int size = resultSizeMap.remove(result);
+      assert(size != null);
+      currentSize -= size;
+      if (currentSize <= maxSize) {
+        break;
+      }
+    }
+    recentlyUsed.removeAll(resultsToFlush);
+    return resultsToFlush;
+  }
+
+  /**
+   * Notifies this manager that the corresponding analysis context is acive.

[Brian Wilkerson, 2015/05/07 14:19:19]

"acive" --> "active"

[scheglov, 2015/05/07 15:49:27]

Done.

+   */
+  void madeActive() {
+    maxSize = maxActiveSize;
+  }
+
+  /**
+   * Notifies this manager that the corresponding analysis context is idle.
+   * Returns [TargetedResult]s that should be flushed from the cache.
+   */
+  List<TargetedResult> madeIdle() {
+    maxSize = maxIdleSize;
+    return flushToSize();
+  }
+
+  /**
+   * Records that the given [result] was just read from the cache.
+   */
+  void resultAccessed(TargetedResult result) {
+    if (recentlyUsed.remove(result)) {
+      recentlyUsed.add(result);

[Brian Wilkerson, 2015/05/07 14:19:19]

Given that an access is a use, shouldn't the result be unconditionally added?

In fact, in the old code only an access was considered a use, storing a value
wasn't.

[scheglov, 2015/05/07 15:49:27]

Yes, access is a use, but only if the result was already stored.
We need values so that we could compute their sizes and manage the list.

+    }
+  }
+
+  /**
+   * Records that the given [newResult] and [newValue] were stored to the cache.
+   * Returns [TargetedResult]s that should be flushed from the cache.
+   */
+  List<TargetedResult> resultStored(TargetedResult newResult, T newValue) {
+    if (!recentlyUsed.remove(newResult)) {
+      int size = policy.measure(newValue);
+      resultSizeMap[newResult] = size;
+      currentSize += size;
+    }
+    recentlyUsed.add(newResult);
+    return flushToSize();
+  }
+
+  /**
+   * Records that the given [target] was just removed from to the cache.
+   */
+  void targetRemoved(AnalysisTarget target) {
+    List<TargetedResult> resultsToRemove = <TargetedResult>[];
+    for (TargetedResult result in recentlyUsed) {
+      if (result.target == target) {
+        resultsToRemove.add(result);
+        int size = resultSizeMap.remove(result);
+        assert(size != null);
+        currentSize -= size;
+      }
+    }
+    recentlyUsed.removeAll(resultsToRemove);
+  }
+}
+
+/**
  * A single partition in an LRU cache of information related to analysis.
  */
 abstract class CachePartition {
   /**
+   * The [AnalysisCache] that owns this partition.
+   *
+   * TODO(scheglov) It seems wrong. Partitions may be shared between caches.
+   * But we need a way to go from every "enclosing" partition into "enclosed"
+   * ones.

[Brian Wilkerson, 2015/05/07 14:19:19]

I'm guessing that this is effectively the same as "context._cache". Perhaps we
should just make the context's cache visible through InternalAnalysisContext.

[scheglov, 2015/05/07 15:49:27]

There are some problems with it in tests.
I will do this in the next CL.

+   */
+  AnalysisCache _cache;
+
+  /**
    * The context that owns this partition. Multiple contexts can reference a
    * partition, but only one context can own it.
    */
   final InternalAnalysisContext context;
 
   /**
-   * The maximum number of sources for which AST structures should be kept in
-   * the cache.
+   * A table mapping caching policies to the cache flush managers.
    */
-  int _maxCacheSize = 0;
-
-  /**
-   * The policy used to determine which results to remove from the cache.
-   */
-  final CacheRetentionPolicy _retentionPolicy;
+  final HashMap<ResultCachingPolicy, CacheFlushManager> _flushManagerMap =
+      new HashMap<ResultCachingPolicy, CacheFlushManager>();
 
   /**
    * A table mapping the targets belonging to this partition to the information
    * known about those targets.
    */
   HashMap<AnalysisTarget, CacheEntry> _targetMap =
       new HashMap<AnalysisTarget, CacheEntry>();
 
   /**
-   * A list containing the most recently accessed targets with the most recently
-   * used at the end of the list. When more targets are added than the maximum
-   * allowed then the least recently used target will be removed and will have
-   * it's cached AST structure flushed.
+   * Initialize a newly created cache partition, belonging to the given
+   * [context].
    */
-  List<AnalysisTarget> _recentlyUsed = <AnalysisTarget>[];
-
-  /**
-   * Initialize a newly created cache partition, belonging to the given
-   * [context]. The partition will maintain at most [_maxCacheSize] AST
-   * structures in the cache, using the [_retentionPolicy] to determine which
-   * AST structures to flush.
-   */
-  CachePartition(this.context, this._maxCacheSize, this._retentionPolicy);
-
-  /**
-   * Return the number of entries in this partition that have an AST associated
-   * with them.
-   */
-  int get astSize {
-    int astSize = 0;
-    int count = _recentlyUsed.length;
-    for (int i = 0; i < count; i++) {
-      AnalysisTarget target = _recentlyUsed[i];
-      CacheEntry entry = _targetMap[target];
-      if (entry.hasAstStructure) {
-        astSize++;
-      }
-    }
-    return astSize;
-  }
+  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.
    */
   Map<AnalysisTarget, CacheEntry> get map => _targetMap;
 
   /**
-   * Return the maximum size of the cache.
-   */
-  int get maxCacheSize => _maxCacheSize;
-
-  /**
-   * Set the maximum size of the cache to the given [size].
-   */
-  void set maxCacheSize(int size) {
-    _maxCacheSize = size;
-    while (_recentlyUsed.length > _maxCacheSize) {
-      if (!_flushAstFromCache()) {
-        break;
-      }
-    }
-  }
-
-  /**
-   * Record that the AST associated with the given [target] was just read from
-   * the cache.
-   */
-  void accessedAst(AnalysisTarget target) {
-    if (_recentlyUsed.remove(target)) {
-      _recentlyUsed.add(target);
-      return;
-    }
-    while (_recentlyUsed.length >= _maxCacheSize) {
-      if (!_flushAstFromCache()) {
-        break;
-      }
-    }
-    _recentlyUsed.add(target);
-  }
-
-  /**
    * Return `true` if the given [target] is contained in this partition.
    */
   // TODO(brianwilkerson) Rename this to something more meaningful, such as
   // isResponsibleFor.
   bool contains(AnalysisTarget target);
 
   /**
    * Return the entry associated with the given [target].
    */
   CacheEntry get(AnalysisTarget target) => _targetMap[target];
 
   /**
    * Return an iterator returning all of the map entries mapping targets to
    * cache entries.
    */
   MapIterator<AnalysisTarget, CacheEntry> iterator() =>
       new SingleMapIterator<AnalysisTarget, CacheEntry>(_targetMap);
 
   /**
    * Associate the given [entry] with the given [target].
    */
   void put(AnalysisTarget target, CacheEntry entry) {
+    entry._partition = this;

[Brian Wilkerson, 2015/05/07 14:19:19]

It would be good to ensure that "entry._partition" is null on entry as a way of
catching bugs.

[scheglov, 2015/05/07 15:49:27]

Done.

+    entry._target = target;

[Brian Wilkerson, 2015/05/07 14:19:19]

It seems strange to assign the target here. It would seem more natural to assign
it outside this method, but I don't know what the implications of that choice
would be, so perhaps this is actually better. In any case, it's something we can
revisit later.

[scheglov, 2015/05/07 15:49:27]

Yes.
Probably more natural would be to make target a final field (we don't repurpose
entries for different targets) and use it during "put".

     entry.fixExceptionState();
     _targetMap[target] = entry;
   }
 
   /**
    * Remove all information related to the given [target] from this cache.
    */
   void remove(AnalysisTarget target) {
-    _recentlyUsed.remove(target);
+    for (CacheFlushManager flushManager in _flushManagerMap.values) {
+      flushManager.targetRemoved(target);
+    }
     _targetMap.remove(target);
   }
 
   /**
-   * Record that the AST associated with the given [target] was just removed
-   * from the cache.
+   * Records that a value of the result described by the given [descriptor]
+   * for the given [target] was just read from the cache.
    */
-  void removedAst(AnalysisTarget target) {
-    _recentlyUsed.remove(target);
+  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);
+    for (TargetedResult result in resultsToFlush) {
+      CacheEntry entry = get(result.target);
+      ResultData data = entry._resultMap[result.result];
+      data.flush();
+    }
   }
 
   /**
    * Return the number of targets that are mapped to cache entries.
    */
   int size() => _targetMap.length;
 
-  /**
-   * Record that the AST associated with the given [target] was just stored to
-   * the cache.
-   */
-  void storedAst(AnalysisTarget target) {
-    if (_recentlyUsed.contains(target)) {
-      return;
-    }
-    while (_recentlyUsed.length >= _maxCacheSize) {
-      if (!_flushAstFromCache()) {
-        break;
-      }
-    }
-    _recentlyUsed.add(target);
+  ResultData _getDataFor(TargetedResult result) {
+    return _cache._getDataFor(result);
   }
 
   /**
-   * Attempt to flush one AST structure from the cache. Return `true` if a
-   * structure was flushed.
+   * Return the [CacheFlushManager] for the given [descriptor], not `null`.
    */
-  bool _flushAstFromCache() {
-    AnalysisTarget removedTarget = _removeAstToFlush();
-    if (removedTarget == null) {
-      return false;
-    }
-    CacheEntry entry = _targetMap[removedTarget];
-    entry.flushAstStructures();
-    return true;
+  CacheFlushManager _getFlushManager(ResultDescriptor descriptor) {
+    ResultCachingPolicy policy = descriptor.cachingPolicy;
+    return _flushManagerMap.putIfAbsent(
+        policy, () => new CacheFlushManager(policy, _isPriorityAnalysisTarget));
   }
 
-  /**
-   * Remove and return one target from the list of recently used targets whose
-   * AST structure can be flushed from the cache,  or `null` if none of the
-   * targets can be removed. The target that will be returned will be the target
-   * that has been unreferenced for the longest period of time but that is not a
-   * priority for analysis.
-   */
-  AnalysisTarget _removeAstToFlush() {
-    int targetToRemove = -1;
-    for (int i = 0; i < _recentlyUsed.length; i++) {
-      AnalysisTarget target = _recentlyUsed[i];
-      RetentionPriority priority =
-          _retentionPolicy.getAstPriority(target, _targetMap[target]);
-      if (priority == RetentionPriority.LOW) {
-        return _recentlyUsed.removeAt(i);
-      } else if (priority == RetentionPriority.MEDIUM && targetToRemove < 0) {
-        targetToRemove = i;
-      }
-    }
-    if (targetToRemove < 0) {
-      // This happens if the retention policy returns a priority of HIGH for all
-      // of the targets that have been recently used. This is the case, for
-      // example, when the list of priority sources is bigger than the current
-      // cache size.
-      return null;
-    }
-    return _recentlyUsed.removeAt(targetToRemove);
+  bool _isPriorityAnalysisTarget(AnalysisTarget target) {
+    return context.priorityTargets.contains(target);
   }
 }
 
-/**
- * A policy objecy that determines how important it is for data to be retained
- * in the analysis cache.
- */
-abstract class CacheRetentionPolicy {
-  /**
-   * Return the priority of retaining the AST structure for the given [target]
-   * in the given [entry].
-   */
-  // TODO(brianwilkerson) Find a more general mechanism, probably based on task
-  // descriptors, to determine which data is still needed for analysis and which
-  // can be removed from the cache. Ideally we could (a) remove the need for
-  // this class and (b) be able to flush all result data (not just AST's).
-  RetentionPriority getAstPriority(AnalysisTarget target, CacheEntry entry);
-}
-
-/**
- * A retention policy that will keep AST's in the cache if there is analysis
- * information that needs to be computed for a source, where the computation is
- * dependent on having the AST.
- */
-class DefaultRetentionPolicy implements CacheRetentionPolicy {
-  /**
-   * An instance of this class that can be shared.
-   */
-  static const DefaultRetentionPolicy POLICY = const DefaultRetentionPolicy();
-
-  /**
-   * Initialize a newly created instance of this class.
-   */
-  const DefaultRetentionPolicy();
-
-  // TODO(brianwilkerson) Implement or delete this.
-//  /**
-//   * Return `true` if there is analysis information in the given entry that needs to be
-//   * computed, where the computation is dependent on having the AST.
-//   *
-//   * @param dartEntry the entry being tested
-//   * @return `true` if there is analysis information that needs to be computed from the AST
-//   */
-//  bool astIsNeeded(DartEntry dartEntry) =>
-//      dartEntry.hasInvalidData(DartEntry.HINTS) ||
-//          dartEntry.hasInvalidData(DartEntry.LINTS) ||
-//          dartEntry.hasInvalidData(DartEntry.VERIFICATION_ERRORS) ||
-//          dartEntry.hasInvalidData(DartEntry.RESOLUTION_ERRORS);
-
-  @override
-  RetentionPriority getAstPriority(AnalysisTarget target, CacheEntry entry) {
-    // TODO(brianwilkerson) Implement or replace this.
-//    if (sourceEntry is DartEntry) {
-//      DartEntry dartEntry = sourceEntry;
-//      if (astIsNeeded(dartEntry)) {
-//        return RetentionPriority.MEDIUM;
-//      }
-//    }
-//    return RetentionPriority.LOW;
-    return RetentionPriority.MEDIUM;
-  }
-}
-
 /**
  * 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;
@@ skipping 35 matching lines @@
   }
 
   /**
    * Add the given [result] to the list of dependent results.
    */
   void addDependentResult(TargetedResult result) {
     dependentResults.add(result);
   }
 
   /**
+   * Flush this value.
+   */
+  void flush() {
+    state = CacheState.FLUSHED;
+    value = descriptor.defaultValue;
+  }
+
+  /**
    * Invalidate this [ResultData] that corresponds to [thisResult] and
    * propagate invalidation to the results that depend on this one.
    */
-  void invalidate(
-      AnalysisCache cache, TargetedResult thisResult, CacheState newState) {
+  void invalidate(CachePartition partition, TargetedResult thisResult,
+      CacheState newState) {
     // Invalidate this result.
     state = newState;
     value = descriptor.defaultValue;
     // Stop depending on other results.
     List<TargetedResult> dependedOnResults = this.dependedOnResults;
     this.dependedOnResults = <TargetedResult>[];
     dependedOnResults.forEach((TargetedResult dependedOnResult) {
-      ResultData data = cache._getDataFor(dependedOnResult);
+      ResultData data = partition._getDataFor(dependedOnResult);
       data.removeDependentResult(thisResult);
     });
     // Invalidate results that depend on this result.
     List<TargetedResult> dependentResults = this.dependentResults;
     this.dependentResults = <TargetedResult>[];
     dependentResults.forEach((TargetedResult dependentResult) {
-      ResultData data = cache._getDataFor(dependentResult);
-      data.invalidate(cache, dependentResult, newState);
+      ResultData data = partition._getDataFor(dependentResult);
+      data.invalidate(partition, dependentResult, newState);
     });
   }
 
   /**
    * Remove the given [result] from the list of dependent results.
    */
   void removeDependentResult(TargetedResult result) {
     dependentResults.remove(result);
   }
 
   /**
    * Set the [dependedOn] on which this result depends.
    */
-  void setDependedOnResults(AnalysisCache cache, TargetedResult thisResult,
+  void setDependedOnResults(CachePartition partition, TargetedResult thisResult,
       List<TargetedResult> dependedOn) {
     dependedOnResults.forEach((TargetedResult dependedOnResult) {
-      ResultData data = cache._getDataFor(dependedOnResult);
+      ResultData data = partition._getDataFor(dependedOnResult);
       data.removeDependentResult(thisResult);
     });
     dependedOnResults = dependedOn;
     dependedOnResults.forEach((TargetedResult dependentResult) {
-      ResultData data = cache._getDataFor(dependentResult);
+      ResultData data = partition._getDataFor(dependentResult);
       data.addDependentResult(thisResult);
     });
   }
 }
 
 /**
  * A cache partition that contains all of the targets in the SDK.
  */
 class SdkCachePartition extends CachePartition {
   /**
    * Initialize a newly created cache partition, belonging to the given
-   * [context]. The partition will maintain at most [maxCacheSize] AST
-   * structures in the cache.
+   * [context].
    */
-  SdkCachePartition(InternalAnalysisContext context, int maxCacheSize)
-      : super(context, maxCacheSize, DefaultRetentionPolicy.POLICY);
+  SdkCachePartition(InternalAnalysisContext context) : super(context);
 
   @override
   bool contains(AnalysisTarget target) {
     Source source = target.source;
     return source != null && source.isInSystemLibrary;
   }
 }
 
 /**
  * A specification of a specific result computed for a specific target.
@@ skipping 34 matching lines @@
   @override
   String toString() => '$result for $target';
 }
 
 /**
  * A cache partition that contains all targets not contained in other partitions.
  */
 class UniversalCachePartition extends CachePartition {
   /**
    * Initialize a newly created cache partition, belonging to the given
-   * [context]. The partition will maintain at most [maxCacheSize] AST
-   * structures in the cache, using the [retentionPolicy] to determine which
-   * AST structures to flush.
+   * [context].
    */
-  UniversalCachePartition(InternalAnalysisContext context, int maxCacheSize,
-      CacheRetentionPolicy retentionPolicy)
-      : super(context, maxCacheSize, retentionPolicy);
+  UniversalCachePartition(InternalAnalysisContext context) : super(context);
 
   @override
   bool contains(AnalysisTarget target) => true;
 }