Flush results when contexts are made idle.

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';
@@ skipping 922 matching lines @@
   /**
    * The current maximum cache size.
    */
   int maxSize;
 
   CacheFlushManager(
       ResultCachingPolicy<T> policy, this.isPriorityAnalysisTarget)
       : policy = policy,
         maxActiveSize = policy.maxActiveSize,
         maxIdleSize = policy.maxIdleSize,
-        maxSize = policy.maxIdleSize;
+        maxSize = policy.maxActiveSize;
 
   /**
    * If [currentSize] is already less than [maxSize], returns an empty list.
    * Otherwise returns [TargetedResult]s to flush from the cache to make
    * [currentSize] less or equal to [maxSize].
    *
    * Results for priority files are never flushed, so this method might leave
    * [currentSize] greater than [maxSize].
    */
   List<TargetedResult> flushToSize() {
@@ skipping 120 matching lines @@
    */
   final Map<String, List<Source>> pathToSource = <String, List<Source>>{};
 
   /**
    * Initialize a newly created cache partition, belonging to the given
    * [context].
    */
   CachePartition(this.context);
 
   /**
+   * Specify whether a context that uses this partition is being analyzed.
+   */
+  set isActive(bool active) {
+    for (CacheFlushManager manager in _flushManagerMap.values) {
+      if (active) {
+        manager.madeActive();
+      } else {
+        List<TargetedResult> resultsToFlush = manager.madeIdle();
+        _flushResults(resultsToFlush);
+      }
+    }
+  }
+
+  /**
    * Notifies the partition that the client is going to stop using it.
    */
   void dispose() {
     for (CacheEntry entry in entryMap.values) {
       entry.dispose();
     }
     entryMap.clear();
     sources.clear();
     pathToSource.clear();
   }
@@ skipping 75 matching lines @@
     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);
-      if (entry != null) {
-        ResultData data = entry._resultMap[result.result];
-        if (data != null) {
-          data.flush();
-        }
-      }
-    }
+    _flushResults(resultsToFlush);
   }
 
   /**
    * Return the number of targets that are mapped to cache entries.
    */
   int size() => entryMap.length;
 
   /**
    * If the given [target] is a [Source], adds it to [sources].
    */
   void _addIfSource(AnalysisTarget target) {
     if (target is Source) {
       sources.add(target);
       String fullName = target.fullName;
       pathToSource.putIfAbsent(fullName, () => <Source>[]).add(target);
     }
   }
 
   /**
+   * Flush the given [resultsToFlush].
+   */
+  void _flushResults(List<TargetedResult> resultsToFlush) {
+    for (TargetedResult result in resultsToFlush) {
+      CacheEntry entry = get(result.target);
+      if (entry != null) {
+        ResultData data = entry._resultMap[result.result];
+        if (data != null) {
+          data.flush();
+        }
+      }
+    }
+  }
+
+  /**
    * Return the [CacheFlushManager] for the given [descriptor], not `null`.
    */
   CacheFlushManager _getFlushManager(ResultDescriptor descriptor) {
     ResultCachingPolicy policy = descriptor.cachingPolicy;
     if (identical(policy, DEFAULT_CACHING_POLICY)) {
       return UnlimitedCacheFlushManager.INSTANCE;
     }
     CacheFlushManager manager = _flushManagerMap[policy];
     if (manager == null) {
       manager = new CacheFlushManager(policy, _isPriorityAnalysisTarget);
@@ skipping 301 matching lines @@
   void resultAccessed(TargetedResult result) {}
 
   @override
   List<TargetedResult> resultStored(TargetedResult newResult, newValue) {
     return TargetedResult.EMPTY_LIST;
   }
 
   @override
   void targetRemoved(AnalysisTarget target) {}
 }