Set CacheEntry.target in the contructor.

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 97 matching lines @@
   MapIterator<AnalysisTarget, CacheEntry> iterator() {
     int count = _partitions.length;
     List<Map<AnalysisTarget, CacheEntry>> maps = new List<Map>(count);
     for (int i = 0; i < count; i++) {
       maps[i] = _partitions[i].map;
     }
     return new MultipleMapIterator<AnalysisTarget, CacheEntry>(maps);
   }
 
   /**
-   * Associate the given [entry] with the given [target].
+   * Puts the given [entry] into the cache.
    */
-  void put(AnalysisTarget target, CacheEntry entry) {
+  void put(CacheEntry entry) {
+    AnalysisTarget target = entry.target;
     entry.fixExceptionState();
     int count = _partitions.length;
     for (int i = 0; i < count; i++) {
       CachePartition partition = _partitions[i];
       if (partition.isResponsibleFor(target)) {
         if (_TRACE_CHANGES) {
           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)}');
           }
         }
-        partition.put(target, entry);
+        partition.put(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.
    */
@@ skipping 38 matching lines @@
  */
 class CacheEntry {
   /**
    * The index of the flag indicating whether the source was explicitly added to
    * the context or whether the source was implicitly added because it was
    * referenced by another source.
    */
   static int _EXPLICITLY_ADDED_FLAG = 0;
 
   /**
+   * The target this entry is about.
+   */
+  final AnalysisTarget target;
+
+  /**
    * The partition that is responsible for this entry.
    */
   CachePartition _partition;
 
   /**
-   * The target this entry is about.
-   */
-  AnalysisTarget _target;
-
-  /**
    * The most recent time at which the state of the target matched the state
    * represented by this entry.
    */
   int modificationTime = 0;
 
   /**
    * The exception that caused one or more values to have a state of
    * [CacheState.ERROR].
    */
   CaughtException _exception;
 
   /**
    * A bit-encoding of boolean flags associated with this entry's target.
    */
   int _flags = 0;
 
   /**
    * A table mapping result descriptors to the cached values of those results.
    */
   Map<ResultDescriptor, ResultData> _resultMap =
       new HashMap<ResultDescriptor, ResultData>();
 
+  CacheEntry(this.target);
+
   /**
    * The exception that caused one or more values to have a state of
    * [CacheState.ERROR].
    */
   CaughtException get exception => _exception;
 
   /**
    * Return `true` if the source was explicitly added to the context or `false`
    * if the source was implicitly added because it was referenced by another
    * source.
@@ skipping 42 matching lines @@
   /**
    * Return the value of the result represented by the given [descriptor], or
    * the default value for the result if this entry does not have a valid value.
    */
   /*<V>*/ dynamic /*V*/ getValue(ResultDescriptor /*<V>*/ descriptor) {
     ResultData data = _resultMap[descriptor];
     if (data == null) {
       return descriptor.defaultValue;
     }
     if (_partition != null) {
-      _partition.resultAccessed(_target, descriptor);
+      _partition.resultAccessed(target, descriptor);
     }
     return data.value;
   }
 
   /**
    * Return `true` if the state of any data value is [CacheState.ERROR].
    */
   bool hasErrorState() {
     for (ResultData data in _resultMap.values) {
       if (data.state == CacheState.ERROR) {
@@ skipping 75 matching lines @@
   }
 
   /**
    * Set the value of the result represented by the given [descriptor] to the
    * given [value]. The optional [memento] may help to recompute [value] more
    * efficiently after invalidation.
    */
   /*<V>*/ void setValue(ResultDescriptor /*<V>*/ descriptor, dynamic /*V*/
       value, List<TargetedResult> dependedOn, Object memento) {
     _validateStateChange(descriptor, CacheState.VALID);
-    TargetedResult thisResult = new TargetedResult(_target, descriptor);
+    TargetedResult thisResult = new TargetedResult(target, descriptor);
     if (_partition != null) {
       _partition.resultStored(thisResult, value);
     }
     _invalidate(descriptor, null);
     ResultData data = _getResultData(descriptor);
     _setDependedOnResults(data, thisResult, dependedOn);
     data.state = CacheState.VALID;
     data.value = value == null ? descriptor.defaultValue : value;
     data.memento = memento;
   }
@@ skipping 26 matching lines @@
     ResultData thisData = _getResultData(descriptor);
     // Invalidate this result.
     if (exception == null) {
       thisData.state = CacheState.INVALID;
     } else {
       thisData.state = CacheState.ERROR;
       _exception = exception;
     }
     thisData.value = descriptor.defaultValue;
     // Stop depending on other results.
-    TargetedResult thisResult = new TargetedResult(_target, descriptor);
+    TargetedResult thisResult = new TargetedResult(target, descriptor);
     List<TargetedResult> dependedOnResults = thisData.dependedOnResults;
     thisData.dependedOnResults = <TargetedResult>[];
     dependedOnResults.forEach((TargetedResult dependedOnResult) {
       ResultData data = _partition._getDataFor(dependedOnResult);
       data.dependentResults.remove(thisResult);
     });
     // Invalidate results that depend on this result.
     List<TargetedResult> dependentResults = thisData.dependentResults;
     thisData.dependentResults = <TargetedResult>[];
     dependentResults.forEach((TargetedResult dependentResult) {
@@ skipping 241 matching lines @@
   CacheEntry get(AnalysisTarget target) => _targetMap[target];
 
   /**
    * Return an iterator returning all of the map entries mapping targets to
    * cache entries.
    */
   MapIterator<AnalysisTarget, CacheEntry> iterator() =>
       new SingleMapIterator<AnalysisTarget, CacheEntry>(_targetMap);
 
   /**
-   * Associate the given [entry] with the given [target].
+   * Puts the given [entry] into the partition.
    */
-  void put(AnalysisTarget target, CacheEntry entry) {
+  void put(CacheEntry entry) {
+    AnalysisTarget target = entry.target;
     if (entry._partition != null) {
       throw new StateError(
           'The entry for $target is already in ${entry._partition}');
     }
     entry._partition = this;
-    entry._target = target;
     entry.fixExceptionState();
     _targetMap[target] = entry;
   }
 
   /**
    * Remove all information related to the given [target] from this cache.
    */
   void remove(AnalysisTarget target) {
     for (CacheFlushManager flushManager in _flushManagerMap.values) {
       flushManager.targetRemoved(target);
@@ skipping 171 matching lines @@
 class UniversalCachePartition extends CachePartition {
   /**
    * Initialize a newly created cache partition, belonging to the given
    * [context].
    */
   UniversalCachePartition(InternalAnalysisContext context) : super(context);
 
   @override
   bool isResponsibleFor(AnalysisTarget target) => true;
 }