Add and use AnalysisCache.sources getter.

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 42 matching lines @@
 //    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.
+   */
+  Iterable<Source> get sources {
+    return _partitions
+        .map((CachePartition partition) => partition._sources)
+        .expand((Iterable<Source> sources) => sources);
+  }
+
+  /**
    * 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 375 matching lines @@
     thisData.dependentResults = <TargetedResult>[];
     dependentResults.forEach((TargetedResult dependentResult) {
       CacheEntry entry = _partition.get(dependentResult.target);
       if (entry != null) {
         entry._invalidate(dependentResult.result);
       }
     });
     // If empty, remove the entry altogether.
     if (_resultMap.isEmpty) {
       _partition._targetMap.remove(target);
+      _partition._removeSource(target);
     }
   }
 
   /**
    * Invalidates all the results of this entry, with propagation.
    */
   void _invalidateAll() {
     List<ResultDescriptor> results = _resultMap.keys.toList();
     for (ResultDescriptor result in results) {
       _invalidate(result);
@@ skipping 232 matching lines @@
       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 set of the [Source] targets.
+   */
+  final HashSet<Source> _sources = new HashSet<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
@@ skipping 23 matching lines @@
    */
   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;
+    _addSource(target);
   }
 
   /**
    * Remove all information related to the given [target] from this cache.
    */
   void remove(AnalysisTarget target) {
     for (CacheFlushManager flushManager in _flushManagerMap.values) {
       flushManager.targetRemoved(target);
     }
     CacheEntry entry = _targetMap.remove(target);
     if (entry != null) {
       entry._invalidateAll();
     }
+    _removeSource(target);
   }
 
   /**
    * 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);
@@ skipping 15 matching lines @@
         }
       }
     }
   }
 
   /**
    * 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 _addSource(AnalysisTarget target) {

[Brian Wilkerson, 2015/05/21 13:52:31]

I was confused when I first saw this method being used because I expected it to
expect the argument to be a Source. Perhaps rename it to "_addIfSource"? (I'm
not sure that's much better, though.) Or maybe just in-line it, given that it's
only used in one place.

+    if (target is Source) {
+      _sources.add(target);
+    }
+  }
+
   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));
   }
 
   bool _isPriorityAnalysisTarget(AnalysisTarget target) {
     return context.priorityTargets.contains(target);
   }
+
+  /**
+   * If the given [target] is a [Source], removes it from [_sources].
+   */
+  void _removeSource(AnalysisTarget target) {
+    if (target is Source) {
+      _sources.remove(target);
+    }
+  }
 }
 
 /**
  * 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.
@@ skipping 105 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;
 }