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

pkg/analyzer/lib/src/task/driver.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.task.driver;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/src/context/cache.dart';
@@ skipping 106 matching lines @@
   WorkOrder createWorkOrderForResult(
       AnalysisTarget target, ResultDescriptor result) {
     CacheEntry entry = context.getCacheEntry(target);
     CacheState state = entry.getState(result);
     if (state == CacheState.VALID ||
         state == CacheState.ERROR ||
         state == CacheState.IN_PROCESS) {
       return null;
     }
     try {
-      return new WorkOrder(taskManager,
-          new WorkItem(context, target, taskManager.findTask(target, result)));
+      TaskDescriptor taskDescriptor = taskManager.findTask(target, result);
+      var memento = entry.getMemento(result);
+      var workItem = new WorkItem(context, target, taskDescriptor, memento);
+      return new WorkOrder(taskManager, workItem);
     } catch (exception, stackTrace) {
       throw new AnalysisException(
           'Could not create work order (target = $target; result = $result)',
           new CaughtException(exception, stackTrace));
     }
   }
 
   /**
    * Create a work order that will produce the required analysis results for
    * the given [target]. If [isPriority] is true, then the target is a priority
@@ skipping 69 matching lines @@
     AnalysisTask task = item.buildTask();
     _onTaskStartedController.add(task);
     task.perform();
     CacheEntry entry = context.getCacheEntry(task.target);
     if (task.caughtException == null) {
       List<TargetedResult> dependedOn = item.inputTargetedResults.toList();
       Map<ResultDescriptor, dynamic> outputs = task.outputs;
       for (ResultDescriptor result in task.descriptor.results) {
         // TODO(brianwilkerson) We could check here that a value was produced
         // and throw an exception if not (unless we want to allow null values).
-        entry.setValue(result, outputs[result], dependedOn);
+        entry.setValue(result, outputs[result], dependedOn, task.outputMemento);
       }
     } else {
       entry.setErrorState(task.caughtException, item.descriptor.results);
     }
     _onTaskCompletedController.add(task);
     return task;
   }
 
   /**
    * Reset the state of the driver in response to a change in the state of one
@@ skipping 44 matching lines @@
    * The target for which a task is to be performed.
    */
   final AnalysisTarget target;
 
   /**
    * A description of the task to be performed.
    */
   final TaskDescriptor descriptor;
 
   /**
+   * The optional data that the task associated with [target] last time.
+   * This data may help to compute outputs more efficiently.
+   */
+  final memento;

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

Should this be "inputMemento"?

+
+  /**
    * An iterator used to iterate over the descriptors of the inputs to the task,
    * or `null` if all of the inputs have been collected and the task can be
    * created.
    */
   TaskInputBuilder builder;
 
   /**
    * The [TargetedResult]s outputs of this task depends on.
    */
   final HashSet<TargetedResult> inputTargetedResults =
       new HashSet<TargetedResult>();
 
   /**
    * The inputs to the task that have been computed.
    */
   Map<String, dynamic> inputs;
 
   /**
    * The exception that was found while trying to populate the inputs. If this
    * field is non-`null`, then the task cannot be performed and all of the
    * results that this task would have computed need to be marked as being in
    * ERROR with this exception.
    */
   CaughtException exception = null;
 
   /**
    * Initialize a newly created work item to compute the inputs for the task
    * described by the given descriptor.
    */
-  WorkItem(this.context, this.target, this.descriptor) {
+  WorkItem(this.context, this.target, this.descriptor, this.memento) {
     AnalysisTarget actualTarget = identical(
             target, AnalysisContextTarget.request)
         ? new AnalysisContextTarget(context)
         : target;
     Map<String, TaskInput> inputDescriptors =
         descriptor.createTaskInputs(actualTarget);
     builder = new TopLevelTaskInputBuilder(inputDescriptors);
     if (!builder.moveNext()) {
       builder = null;
     }
     inputs = new HashMap<String, dynamic>();
   }
 
   /**
    * Build the task represented by this work item.
    */
   AnalysisTask buildTask() {
     if (builder != null) {
       throw new StateError("some inputs have not been computed");
     }
-    return descriptor.createTask(context, target, inputs);
+    return descriptor.createTask(context, target, inputs, memento);
   }
 
   /**
    * Gather all of the inputs needed to perform the task.
    *
    * If at least one of the inputs have not yet been computed, return a work
    * item that can be used to generate that input to indicate that the caller
    * should perform the returned item's task before returning to gathering
    * inputs for this item's task.
    *
@@ skipping 24 matching lines @@
         // next iteration. It would be more efficient, in general, to push this
         // input onto a waiting list and proceed to the next input so that work
         // could proceed, but given that the only result that can currently be
         // IN_PROCESS is CONTENT, I don't know that it's worth the extra effort
         // to implement the general solution at this point.
         //
       } else if (inputState != CacheState.VALID) {
         try {
           TaskDescriptor descriptor =
               taskManager.findTask(inputTarget, inputResult);
-          return new WorkItem(context, inputTarget, descriptor);
+          dynamic memento = inputEntry.getMemento(inputResult);
+          return new WorkItem(context, inputTarget, descriptor, memento);
         } on AnalysisException catch (exception, stackTrace) {
           this.exception = new CaughtException(exception, stackTrace);
           return null;
         }
       }
       builder.currentValue = inputEntry.getValue(inputResult);
       if (!builder.moveNext()) {
         inputs = builder.inputValue;
         builder = null;
       }
@@ skipping 72 matching lines @@
     TaskDescriptor descriptor = currentItem.descriptor;
     AnalysisTarget target = currentItem.target;
     for (WorkItem item in pendingItems) {
       if (item.descriptor == descriptor && item.target == target) {
         return true;
       }
     }
     return false;
   }
 }