Revert "Flush AST results for source outside of the analysis roots."

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 [targetFilter] and [resultFilter].
+   * Flush results that satisfy the given [filter].
    */
-  void flush(FlushTargetFilter targetFilter, FlushResultFilter resultFilter) {
+  void flush(FlushResultFilter filter) {
     for (CachePartition partition in _partitions) {
-      partition.flush(targetFilter, resultFilter);
+      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];
@@ 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 [targetFilter] and [resultFilter].
+   * Flush results that satisfy the given [filter].
    */
-  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();
-          }
-        }
-      });
-    }
+  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));
   }
 
@@ skipping 660 matching lines @@
   void dispose() {
     for (CacheEntry entry in entryMap.values) {
       entry.dispose();
     }
     entryMap.clear();
     sources.clear();
     pathToSource.clear();
   }
 
   /**
-   * Flush results that satisfy the given [targetFilter] and [resultFilter].
+   * Flush results that satisfy the given [filter].
    */
-  void flush(FlushTargetFilter targetFilter, FlushResultFilter resultFilter) {
+  void flush(FlushResultFilter filter) {
     for (CacheEntry entry in entryMap.values) {
-      entry.flush(targetFilter, resultFilter);
+      entry.flush(filter);
     }
   }
 
   /**
    * 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 407 matching lines @@
   void resultAccessed(TargetedResult result) {}
 
   @override
   List<TargetedResult> resultStored(TargetedResult newResult, newValue) {
     return TargetedResult.EMPTY_LIST;
   }
 
   @override
   void targetRemoved(AnalysisTarget target) {}
 }