Get memento objects from tasks, remember in cache and pass back to tasks.

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/ast.dart';
 import 'package:analyzer/src/generated/engine.dart'
@@ skipping 313 matching lines @@
     _resultMap.forEach((ResultDescriptor descriptor, ResultData data) {
       if (data.value is AstNode || data.value is XmlNode) {
         _validateStateChange(descriptor, CacheState.FLUSHED);
         data.state = CacheState.FLUSHED;
         data.value = descriptor.defaultValue;
       }
     });
   }
 
   /**
+   * Return the memento of the result represented by the given [descriptor].
+   */
+  dynamic getMemento(ResultDescriptor descriptor) {
+    ResultData data = _resultMap[descriptor];
+    if (data == null) {
+      return null;
+    }
+    return data.memento;
+  }
+
+  /**
    * Return the state of the result represented by the given [descriptor].
    */
   CacheState getState(ResultDescriptor descriptor) {
     ResultData data = _resultMap[descriptor];
     if (data == null) {
       return CacheState.INVALID;
     }
     return data.state;
   }
 
@@ skipping 90 matching lines @@
         // If the state is in-process, we can leave the current value in the
         // cache for any 'get' methods to access.
         //
         data.value = descriptor.defaultValue;
       }
     }
   }
 
   /**
    * Set the value of the result represented by the given [descriptor] to the
-   * given [value].
+   * 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) {
+      value, List<TargetedResult> dependedOn, [dynamic memento]) {
     _validateStateChange(descriptor, CacheState.VALID);
     ResultData data = _getResultData(descriptor);
     {
       TargetedResult thisResult = new TargetedResult(_target, descriptor);
       data.invalidate(_cache, thisResult, CacheState.INVALID);
       data.setDependedOnResults(_cache, thisResult, dependedOn);
     }
     data.state = CacheState.VALID;
     data.value = value == null ? descriptor.defaultValue : value;
+    data.memento = memento;
   }
 
   @override
   String toString() {
     StringBuffer buffer = new StringBuffer();
     _writeOn(buffer);
     return buffer.toString();
   }
 
   /**
@@ skipping 347 matching lines @@
    */
   CacheState state;
 
   /**
    * The value being cached, or the default value for the result if there is no
    * value (for example, when the [state] is [CacheState.INVALID]).
    */
   Object value;
 
   /**
+   * The optional data that is remembered with [value] and, when [value] is
+   * invalidated, may help to recompute it more efficiently.
+   */
+  dynamic memento;

[Brian Wilkerson, 2015/05/04 16:22:09]

nit: I generally prefer 'Object' over 'dynamic' as an explicit type.

+
+  /**
    * A list of the results on which this result depends.
    */
   List<TargetedResult> dependedOnResults = <TargetedResult>[];
 
   /**
    * A list of the results that depend on this result.
    */
   List<TargetedResult> dependentResults = <TargetedResult>[];
 
   /**
@@ skipping 130 matching lines @@
    * structures in the cache, using the [retentionPolicy] to determine which
    * AST structures to flush.
    */
   UniversalCachePartition(InternalAnalysisContext context, int maxCacheSize,
       CacheRetentionPolicy retentionPolicy)
       : super(context, maxCacheSize, retentionPolicy);
 
   @override
   bool contains(AnalysisTarget target) => true;
 }