Cache flushing implementation for the task model.

pkg/analyzer/lib/src/context/context.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.context;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/src/cancelable_future.dart';
@@ skipping 163 matching lines @@
 
   /**
    * A factory to override how [LibraryResolver] is created.
    */
   LibraryResolverFactory libraryResolverFactory;
 
   /**
    * Initialize a newly created analysis context.
    */
   AnalysisContextImpl() {
-    _privatePartition = new cache.UniversalCachePartition(this,
-        AnalysisOptionsImpl.DEFAULT_CACHE_SIZE,
-        new ContextRetentionPolicy(this));
+    _privatePartition = new cache.UniversalCachePartition(this);
     _cache = createCacheFromSourceFactory(null);
     _taskManager = AnalysisEngine.instance.taskManager;
     _driver = new AnalysisDriver(_taskManager, this);
     _onSourcesChangedController =
         new StreamController<SourcesChangedEvent>.broadcast();
   }
 
   @override
   AnalysisOptions get analysisOptions => _options;
 
   @override
   void set analysisOptions(AnalysisOptions options) {
     bool needsRecompute = this._options.analyzeFunctionBodiesPredicate !=
             options.analyzeFunctionBodiesPredicate ||
         this._options.generateImplicitErrors !=
             options.generateImplicitErrors ||
         this._options.generateSdkErrors != options.generateSdkErrors ||
         this._options.dart2jsHint != options.dart2jsHint ||
         (this._options.hint && !options.hint) ||
         this._options.preserveComments != options.preserveComments ||
         this._options.enableNullAwareOperators !=
             options.enableNullAwareOperators ||
         this._options.enableStrictCallChecks != options.enableStrictCallChecks;
     int cacheSize = options.cacheSize;
     if (this._options.cacheSize != cacheSize) {
       this._options.cacheSize = cacheSize;
-      _privatePartition.maxCacheSize = cacheSize;
     }
     this._options.analyzeFunctionBodiesPredicate =
         options.analyzeFunctionBodiesPredicate;
     this._options.generateImplicitErrors = options.generateImplicitErrors;
     this._options.generateSdkErrors = options.generateSdkErrors;
     this._options.dart2jsHint = options.dart2jsHint;
     this._options.enableNullAwareOperators = options.enableNullAwareOperators;
     this._options.enableStrictCallChecks = options.enableStrictCallChecks;
     this._options.hint = options.hint;
     this._options.incremental = options.incremental;
@@ skipping 138 matching lines @@
    * Return a list of the sources that would be processed by
    * [performAnalysisTask]. This method duplicates, and must therefore be kept
    * in sync with, [getNextAnalysisTask]. This method is intended to be used for
    * testing purposes only.
    */
   List<Source> get sourcesNeedingProcessing {
     HashSet<Source> sources = new HashSet<Source>();
     bool hintsEnabled = _options.hint;
     bool lintsEnabled = _options.lint;
 
-    MapIterator<AnalysisTarget, cache.CacheEntry> iterator = _privatePartition.iterator();
+    MapIterator<AnalysisTarget, cache.CacheEntry> iterator =
+        _privatePartition.iterator();
     while (iterator.moveNext()) {
       AnalysisTarget target = iterator.key;
       if (target is Source) {
         _getSourcesNeedingProcessing(
             target, iterator.value, false, hintsEnabled, lintsEnabled, sources);
       }
     }
     return new List<Source>.from(sources);
   }
 
@@ skipping 451 matching lines @@
     return SourceKind.UNKNOWN;
   }
 
   @override
   List<Source> getLibrariesContaining(Source source) {
     SourceKind kind = getKindOf(source);
     if (kind == SourceKind.LIBRARY) {
       return <Source>[source];
     } else if (kind == SourceKind.PART) {
       List<Source> libraries = <Source>[];
-      MapIterator<AnalysisTarget, cache.CacheEntry> iterator = _cache.iterator();
+      MapIterator<AnalysisTarget, cache.CacheEntry> iterator =
+          _cache.iterator();
       while (iterator.moveNext()) {
         AnalysisTarget target = iterator.key;
         if (target is Source && getKindOf(target) == SourceKind.LIBRARY) {
           List<Source> parts = _getResult(target, INCLUDED_PARTS);
           if (parts.contains(source)) {
             libraries.add(target);
           }
         }
       }
       if (libraries.isNotEmpty) {
@@ skipping 1103 matching lines @@
         buffer.write("    ");
         buffer.writeln(source.fullName);
       }
       _logInformation(buffer.toString());
     }
     return changedTargets.length > 0;
   }
 }
 
 /**
- * A retention policy used by an analysis context.
- */
-class ContextRetentionPolicy implements cache.CacheRetentionPolicy {
-  /**
-   * The context associated with this policy.
-   */
-  final AnalysisContextImpl context;
-
-  /**
-   * Initialize a newly created policy to be associated with the given
-   * [context].
-   */
-  ContextRetentionPolicy(this.context);
-
-  @override
-  RetentionPriority getAstPriority(
-      AnalysisTarget target, cache.CacheEntry entry) {
-    int priorityCount = context._priorityOrder.length;
-    for (int i = 0; i < priorityCount; i++) {
-      if (target == context._priorityOrder[i]) {
-        return RetentionPriority.HIGH;
-      }
-    }
-    if (_astIsNeeded(entry)) {
-      return RetentionPriority.MEDIUM;
-    }
-    return RetentionPriority.LOW;
-  }
-
-  bool _astIsNeeded(cache.CacheEntry entry) =>
-      entry.isInvalid(BUILD_FUNCTION_TYPE_ALIASES_ERRORS) ||
-          entry.isInvalid(BUILD_LIBRARY_ERRORS) ||
-          entry.isInvalid(CONSTRUCTORS_ERRORS) ||
-          entry.isInvalid(HINTS) ||
-          //entry.isInvalid(LINTS) ||
-          entry.isInvalid(RESOLVE_REFERENCES_ERRORS) ||
-          entry.isInvalid(RESOLVE_TYPE_NAMES_ERRORS) ||
-          entry.isInvalid(VERIFY_ERRORS);
-}
-
-/**
  * An object that manages the partitions that can be shared between analysis
  * contexts.
  */
 class PartitionManager {
   /**
-   * The default cache size for a Dart SDK partition.
-   */
-  static int _DEFAULT_SDK_CACHE_SIZE = 256;
-
-  /**
    * A table mapping SDK's to the partitions used for those SDK's.
    */
   HashMap<DartSdk, cache.SdkCachePartition> _sdkPartitions =
       new HashMap<DartSdk, cache.SdkCachePartition>();
 
   /**
    * Clear any cached data being maintained by this manager.
    */
   void clearCache() {
     _sdkPartitions.clear();
   }
 
   /**
    * Return the partition being used for the given [sdk], creating the partition
    * if necessary.
    */
   cache.SdkCachePartition forSdk(DartSdk sdk) {
     // Call sdk.context now, because when it creates a new
     // InternalAnalysisContext instance, it calls forSdk() again, so creates an
     // SdkCachePartition instance.
     // So, if we initialize context after "partition == null", we end up
     // with two SdkCachePartition instances.
     InternalAnalysisContext sdkContext = sdk.context;
     // Check cache for an existing partition.
     cache.SdkCachePartition partition = _sdkPartitions[sdk];
     if (partition == null) {
-      partition =
-          new cache.SdkCachePartition(sdkContext, _DEFAULT_SDK_CACHE_SIZE);
+      partition = new cache.SdkCachePartition(sdkContext);
       _sdkPartitions[sdk] = partition;
     }
     return partition;
   }
 }
 
 /**
  * Representation of a pending computation which is based on the results of
  * analysis that may or may not have been completed.
  */
@@ skipping 113 matching lines @@
     PendingFuture pendingFuture =
         new PendingFuture<T>(_context, target, computeValue);
     if (!pendingFuture.evaluate(entry)) {
       _context._pendingFutureTargets
           .putIfAbsent(target, () => <PendingFuture>[])
           .add(pendingFuture);
     }
     return pendingFuture.future;
   }
 }