Get AnalysisCache from InternalAnalysisContext.

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 22 matching lines @@
    * An array containing the partitions of which this cache is comprised.
    */
   final List<CachePartition> _partitions;
 
   /**
    * Initialize a newly created cache to have the given [partitions]. The
    * partitions will be searched in the order in which they appear in the array,
    * so the most specific partition (usually an [SdkCachePartition]) should be
    * first and the most general (usually a [UniversalCachePartition]) last.
    */
-  AnalysisCache(this._partitions) {
-    for (CachePartition partition in _partitions) {
-      partition._cache = this;
-    }
-  }
+  AnalysisCache(this._partitions);
 
   // TODO(brianwilkerson) Implement or delete this.
 //  /**
 //   * Return information about each of the partitions in this cache.
 //   */
 //  List<AnalysisContextStatistics_PartitionData> get partitionData {
 //    int count = _partitions.length;
 //    List<AnalysisContextStatistics_PartitionData> data =
 //        new List<AnalysisContextStatistics_PartitionData>(count);
 //    for (int i = 0; i < count; i++) {
@@ skipping 540 matching lines @@
     }
     recentlyUsed.removeAll(resultsToRemove);
   }
 }
 
 /**
  * A single partition in an LRU cache of information related to analysis.
  */
 abstract class CachePartition {
   /**
-   * The [AnalysisCache] that owns this partition.
-   *
-   * TODO(scheglov) It seems wrong. Partitions may be shared between caches.
-   * But we need a way to go from every "enclosing" partition into "enclosed"
-   * ones.
-   */
-  AnalysisCache _cache;
-
-  /**
    * The context that owns this partition. Multiple contexts can reference a
    * partition, but only one context can own it.
    */
   final InternalAnalysisContext context;
 
   /**
    * A table mapping caching policies to the cache flush managers.
    */
   final HashMap<ResultCachingPolicy, CacheFlushManager> _flushManagerMap =
       new HashMap<ResultCachingPolicy, CacheFlushManager>();
@@ skipping 86 matching lines @@
       data.flush();
     }
   }
 
   /**
    * Return the number of targets that are mapped to cache entries.
    */
   int size() => _targetMap.length;
 
   ResultData _getDataFor(TargetedResult result) {
-    return _cache._getDataFor(result);
+    return context.analysisCache._getDataFor(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));
   }
@@ skipping 119 matching lines @@
  */
 class SdkCachePartition extends CachePartition {
   /**
    * Initialize a newly created cache partition, belonging to the given
    * [context].
    */
   SdkCachePartition(InternalAnalysisContext context) : super(context);
 
   @override
   bool contains(AnalysisTarget target) {
+    if (target is AnalysisContextTarget) {
+      return true;
+    }
     Source source = target.source;
     return source != null && source.isInSystemLibrary;
   }
 }
 
 /**
  * A specification of a specific result computed for a specific target.
  */
 class TargetedResult {
   /**
@@ skipping 38 matching lines @@
 class UniversalCachePartition extends CachePartition {
   /**
    * Initialize a newly created cache partition, belonging to the given
    * [context].
    */
   UniversalCachePartition(InternalAnalysisContext context) : super(context);
 
   @override
   bool contains(AnalysisTarget target) => true;
 }