Use FlushTargetFilter to pre-filter targets before checking their results.

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

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library analyzer.src.context.cache;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/src/generated/engine.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/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 some results of the [target] should be flushed.
+ */
+typedef bool FlushTargetFilter<V>(AnalysisTarget target);
+
+/**
  * 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
@@ skipping 66 matching lines @@
     for (ReentrantSynchronousStreamSubscription subscription
         in onResultInvalidatedPartitionSubscriptions) {
       subscription.cancel();
     }
     for (CachePartition partition in _partitions) {
       partition.containingCaches.remove(this);
     }
   }
 
   /**
-   * Flush results that satisfy the given [filter].
+   * Flush results that satisfy the given [targetFilter] and [resultFilter].
    */
-  void flush(FlushResultFilter filter) {
+  void flush(FlushTargetFilter targetFilter, FlushResultFilter resultFilter) {
     for (CachePartition partition in _partitions) {
-      partition.flush(filter);
+      partition.flush(targetFilter, resultFilter);
     }
   }
 
   /**
    * 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];
@@ skipping 267 matching lines @@
   /**
    * Fix the state of the [exception] to match the current state of the entry.
    */
   void fixExceptionState() {
     if (!hasErrorState()) {
       _exception = null;
     }
   }
 
   /**
-   * Flush results that satisfy the given [filter].
+   * Flush results that satisfy the given [targetFilter] and [resultFilter].
    */
-  void flush(FlushResultFilter filter) {
-    _resultMap.forEach((ResultDescriptor result, ResultData data) {
-      if (data.state == CacheState.VALID) {
-        if (filter(target, result)) {
-          data.flush();
+  void flush(FlushTargetFilter targetFilter, FlushResultFilter resultFilter) {
+    if (targetFilter(target)) {
+      _resultMap.forEach((ResultDescriptor result, ResultData data) {
+        if (data.state == CacheState.VALID) {
+          if (resultFilter(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));
   }
 
@@ skipping 657 matching lines @@
   void dispose() {
     for (CacheEntry entry in entryMap.values) {
       entry.dispose();
     }
     entryMap.clear();
     sources.clear();
     pathToSource.clear();
   }
 
   /**
-   * Flush results that satisfy the given [filter].
+   * Flush results that satisfy the given [targetFilter] and [resultFilter].
    */
-  void flush(FlushResultFilter filter) {
+  void flush(FlushTargetFilter targetFilter, FlushResultFilter resultFilter) {
     for (CacheEntry entry in entryMap.values) {
-      entry.flush(filter);
+      entry.flush(targetFilter, resultFilter);
     }
   }
 
   /**
    * Return the entry associated with the given [target].
    */
   CacheEntry get(AnalysisTarget target) => entryMap[target];
 
   /**
    * Return [Source]s whose full path is equal to the given [path].
@@ skipping 391 matching lines @@
   void resultAccessed(TargetedResult result) {}
 
   @override
   List<TargetedResult> resultStored(TargetedResult newResult, newValue) {
     return TargetedResult.EMPTY_LIST;
   }
 
   @override
   void targetRemoved(AnalysisTarget target) {}
 }