Automatically remove empty entries from the cache.

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/engine.dart'
     show AnalysisEngine, CacheState, InternalAnalysisContext, RetentionPriority;
@@ skipping 154 matching lines @@
    * 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;
   }
-
-  ResultData _getDataFor(TargetedResult result) {
-    CacheEntry entry = get(result.target);
-    if (entry != null) {
-      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.
@@ skipping 133 matching lines @@
   void setErrorState(
       CaughtException exception, List<ResultDescriptor> descriptors) {
     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) {
-      _invalidate(descriptor, exception);
+      _setErrorState(descriptor, exception);
     }
   }
 
   /**
    * 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) {
-        _invalidate(descriptor, null);
+        _invalidate(descriptor, true);
       }
     } 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, List<TargetedResult> dependedOn) {
     _validateStateChange(descriptor, CacheState.VALID);
     TargetedResult thisResult = new TargetedResult(target, descriptor);
     if (_partition != null) {
       _partition.resultStored(thisResult, value);
     }
-    _invalidate(descriptor, null);
+    _invalidate(descriptor, false);
     ResultData data = _getResultData(descriptor);
     _setDependedOnResults(data, thisResult, dependedOn);
     data.state = CacheState.VALID;
     data.value = value == null ? descriptor.defaultValue : value;
   }
 
   @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);
 
   /**
    * Look up the [ResultData] of [descriptor], or add a new one if it isn't
    * there.
    */
   ResultData _getResultData(ResultDescriptor descriptor) {
     return _resultMap.putIfAbsent(descriptor, () => new ResultData(descriptor));
   }
 
   /**
-   * Invalidate the result represented by the given [descriptor].
-   * Propagate invalidation to other results that depend on it.
+   * Invalidate the result represented by the given [descriptor] if
+   * [includeThis] is true. Propagate invalidation to other results that
+   * depend on it.
    */
-  void _invalidate(ResultDescriptor descriptor, CaughtException exception) {
-    ResultData thisData = _getResultData(descriptor);
-    // Invalidate this result.
-    if (exception == null) {
-      thisData.state = CacheState.INVALID;
+  void _invalidate(ResultDescriptor descriptor, bool includeThis) {
+    ResultData thisData;
+    if (includeThis) {
+      thisData = _resultMap.remove(descriptor);
     } else {
-      thisData.state = CacheState.ERROR;
-      _exception = exception;
+      thisData = _resultMap[descriptor];
     }
-    thisData.value = descriptor.defaultValue;
+    if (thisData == null) {
+      return;
+    }
     // Stop depending on other results.
     TargetedResult thisResult = new TargetedResult(target, descriptor);
-    List<TargetedResult> dependedOnResults = thisData.dependedOnResults;
-    thisData.dependedOnResults = <TargetedResult>[];
-    dependedOnResults.forEach((TargetedResult dependedOnResult) {
-      ResultData data = _partition._getDataFor(dependedOnResult);
-      data.dependentResults.remove(thisResult);
+    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.
     List<TargetedResult> dependentResults = thisData.dependentResults;
     thisData.dependentResults = <TargetedResult>[];
     dependentResults.forEach((TargetedResult dependentResult) {
       CacheEntry entry = _partition.get(dependentResult.target);
-      entry._invalidate(dependentResult.result, exception);
+      entry._invalidate(dependentResult.result, true);
     });
+    // If empty, remove the entry altogether.
+    if (_resultMap.isEmpty) {
+      _partition._targetMap.remove(target);
+    }
   }
 
   /**
    * Set the [dependedOn] on which this result depends.
    */
   void _setDependedOnResults(ResultData thisData, TargetedResult thisResult,
       List<TargetedResult> dependedOn) {
     thisData.dependedOnResults = dependedOn;
     thisData.dependedOnResults.forEach((TargetedResult dependentResult) {
       ResultData data = _partition._getDataFor(dependentResult);
       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.
+    thisData.dependentResults.forEach((TargetedResult dependentResult) {
+      CacheEntry entry = _partition.get(dependentResult.target);
+      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);
   }
 
   /**
    * If the state of the value described by the given [descriptor] is changing
    * from ERROR to anything else, capture the information. This is an attempt to
    * discover the underlying cause of a long-standing bug.
@@ skipping 196 matching lines @@
   /**
    * 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 entry associated with the given [target].
+   */
+  CacheEntry get(AnalysisTarget target) => _targetMap[target];
+
+  /**
    * Return `true` if this partition is responsible for the given [target].
    */
   bool isResponsibleFor(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);
 
   /**
    * Puts the given [entry] into the partition.
    */
   void put(CacheEntry entry) {
@@ skipping 29 matching lines @@
 
   /**
    * 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();
+      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;
 
-  ResultData _getDataFor(TargetedResult result) {
-    return context.analysisCache._getDataFor(result);
+  ResultData _getDataFor(TargetedResult result, {bool orNull: false}) {
+    CacheEntry entry = context.analysisCache.get(result.target);
+    if (orNull) {
+      return entry != null ? entry._resultMap[result.result] : null;
+    } else {
+      return entry._getResultData(result.result);
+    }
   }
 
   /**
    * Return the [CacheFlushManager] for the given [descriptor], not `null`.
    */
   CacheFlushManager _getFlushManager(ResultDescriptor descriptor) {
     ResultCachingPolicy policy = descriptor.cachingPolicy;
     return _flushManagerMap.putIfAbsent(
         policy, () => new CacheFlushManager(policy, _isPriorityAnalysisTarget));
   }
@@ skipping 119 matching lines @@
 class UniversalCachePartition extends CachePartition {
   /**
    * Initialize a newly created cache partition, belonging to the given
    * [context].
    */
   UniversalCachePartition(InternalAnalysisContext context) : super(context);
 
   @override
   bool isResponsibleFor(AnalysisTarget target) => true;
 }