Some clean ups for cache partitions.

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 47 matching lines @@
 //    }
 //    return data;
 //  }
 
   /**
    * Return the entry associated with the given [target].
    */
   CacheEntry get(AnalysisTarget target) {
     int count = _partitions.length;
     for (int i = 0; i < count; i++) {
-      if (_partitions[i].contains(target)) {
-        return _partitions[i].get(target);
+      CachePartition partition = _partitions[i];
+      if (partition.isResponsibleFor(target)) {
+        return partition.get(target);
       }
     }
     //
     // We should never get to this point because the last partition should
     // always be a universal partition, except in the case of the SDK context,
     // in which case the target should always be part of the SDK.
     //
     return null;
   }
 
   /**
    * Return the context to which the given [target] was explicitly added.
    */
   InternalAnalysisContext getContextFor(AnalysisTarget target) {
     int count = _partitions.length;
     for (int i = 0; i < count; i++) {
-      if (_partitions[i].contains(target)) {
-        return _partitions[i].context;
+      CachePartition partition = _partitions[i];
+      if (partition.isResponsibleFor(target)) {
+        return partition.context;
       }
     }
     //
     // We should never get to this point because the last partition should
     // always be a universal partition, except in the case of the SDK context,
     // in which case the target should always be part of the SDK.
     //
     // TODO(brianwilkerson) Throw an exception here.
     AnalysisEngine.instance.logger.logInformation(
         'Could not find context for $target',
@@ skipping 14 matching lines @@
     return new MultipleMapIterator<AnalysisTarget, CacheEntry>(maps);
   }
 
   /**
    * Associate the given [entry] with the given [target].
    */
   void put(AnalysisTarget target, CacheEntry entry) {
     entry.fixExceptionState();
     int count = _partitions.length;
     for (int i = 0; i < count; i++) {
-      if (_partitions[i].contains(target)) {
+      CachePartition partition = _partitions[i];
+      if (partition.isResponsibleFor(target)) {
         if (_TRACE_CHANGES) {
-          CacheEntry oldEntry = _partitions[i].get(target);
+          CacheEntry oldEntry = partition.get(target);
           if (oldEntry == null) {
             AnalysisEngine.instance.logger
                 .logInformation('Added a cache entry for $target.');
           } else {
             AnalysisEngine.instance.logger
                 .logInformation('Modified the cache entry for $target.');
 //                'Diff = ${entry.getDiff(oldEntry)}');
           }
         }
-        _partitions[i].put(target, entry);
+        partition.put(target, entry);
         return;
       }
     }
     // TODO(brianwilkerson) Handle the case where no partition was found,
     // possibly by throwing an exception.
   }
 
   /**
    * Remove all information related to the given [target] from this cache.
    */
   void remove(AnalysisTarget target) {
     int count = _partitions.length;
     for (int i = 0; i < count; i++) {
-      if (_partitions[i].contains(target)) {
+      CachePartition partition = _partitions[i];
+      if (partition.isResponsibleFor(target)) {
         if (_TRACE_CHANGES) {
           AnalysisEngine.instance.logger
               .logInformation('Removed the cache entry for $target.');
         }
-        _partitions[i].remove(target);
+        partition.remove(target);
         return;
       }
     }
   }
 
   /**
    * Return the number of targets that are mapped to cache entries.
    */
   int size() {
     int size = 0;
     int count = _partitions.length;
     for (int i = 0; i < count; i++) {
       size += _partitions[i].size();
     }
     return size;
   }
 
   ResultData _getDataFor(TargetedResult result) {
-    AnalysisTarget target = result.target;
-    int count = _partitions.length;
-    for (int i = 0; i < count; i++) {
-      if (_partitions[i].contains(target)) {
-        CacheEntry entry = _partitions[i].get(target);
-        return entry._getResultData(result.result);
-      }
+    CacheEntry entry = get(result.target);
+    if (entry != null) {
+      return entry._getResultData(result.result);
     }
     return null;
   }
 }
 
 /**
  * The information cached by an analysis context about an individual target.
  */
 class CacheEntry {
   /**
@@ skipping 479 matching lines @@
   /**
    * Return a table mapping the targets known to the context to the information
    * known about the target.
    *
    * <b>Note:</b> This method is only visible for use by [AnalysisCache] and
    * should not be used for any other purpose.
    */
   Map<AnalysisTarget, CacheEntry> get map => _targetMap;
 
   /**
-   * Return `true` if the given [target] is contained in this partition.
+   * Return `true` if this partition is responsible for the given [target].
    */
-  // TODO(brianwilkerson) Rename this to something more meaningful, such as
-  // isResponsibleFor.
-  bool contains(AnalysisTarget target);
+  bool isResponsibleFor(AnalysisTarget target);

[Brian Wilkerson, 2015/05/07 20:03:07]

Thanks!

 
   /**
    * Return the entry associated with the given [target].
    */
   CacheEntry get(AnalysisTarget target) => _targetMap[target];
 
   /**
    * Return an iterator returning all of the map entries mapping targets to
    * cache entries.
    */
@@ skipping 131 matching lines @@
  * A cache partition that contains all of the targets in the SDK.
  */
 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) {
+  bool isResponsibleFor(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.
@@ skipping 39 matching lines @@
  * A cache partition that contains all targets not contained in other partitions.
  */
 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;
+  bool isResponsibleFor(AnalysisTarget target) => true;
 }