Replace ResultProvider with 'aboutToComputeResult'.

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 26 matching lines @@
    * compute.
    */
   final List<WorkManager> workManagers;
 
   /**
    * The context in which analysis is to be performed.
    */
   final InternalAnalysisContext context;
 
   /**
-   * The alternative source of analysis results.
-   */
-  ResultProvider resultProvider;
-
-  /**
    * The map of [ComputedResult] controllers.
    */
   final Map<ResultDescriptor, StreamController<ComputedResult>>
       resultComputedControllers =
       <ResultDescriptor, StreamController<ComputedResult>>{};
 
   /**
    * The work order that was previously computed but that has not yet been
    * completed.
    */
@@ skipping 103 matching lines @@
       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;
     }
     TaskDescriptor taskDescriptor = taskManager.findTask(target, result);
     try {
-      WorkItem workItem = new WorkItem(
-          context, resultProvider, target, taskDescriptor, result, 0, null);
+      WorkItem workItem =
+          new WorkItem(context, target, taskDescriptor, result, 0, null);
       return new WorkOrder(taskManager, workItem);
     } catch (exception, stackTrace) {
       throw new AnalysisException(
           'Could not create work order (target = $target; taskDescriptor = $taskDescriptor; result = $result)',
           new CaughtException(exception, stackTrace));
     }
   }
 
   /**
    * Create a work order that will produce the required analysis results for
@@ skipping 315 matching lines @@
    * Initialize a newly created exception to represent a failed attempt to
    * perform the given [task] due to the given [dependencyCycle].
    */
   InfiniteTaskLoopException(AnalysisTask task, this.dependencyCycle,
       [this.cyclicPath])
       : super(
             'Infinite loop while performing task ${task.descriptor.name} for ${task.target}');
 }
 
 /**
- * The object used by [WorkItem] to get values without using tasks.
- */
-abstract class ResultProvider {
-  /**
-   * [WorkItem] calls this method when the [result] of the [entry] is
-   * [CacheState.INVALID], so it is about to schedule its computation.
-   *
-   * If the provider knows how to provide the value, it sets the value into
-   * the [entry] with all required dependencies, and returns `true`.
-   *
-   * Otherwise, it returns `false` to indicate that the [WorkItem] should
-   * compute the value.
-   */
-  bool provideResult(InternalAnalysisContext context, CacheEntry entry,
-      ResultDescriptor result);
-}
-
-/**
  * Object used by [CycleAwareDependencyWalker] to report a single strongly
  * connected component of nodes.
  */
 class StronglyConnectedComponent<Node> {
   /**
    * The nodes contained in the strongly connected component.
    */
   final List<Node> nodes;
 
   /**
@@ skipping 11 matching lines @@
  * A description of a single analysis task that can be performed to advance
  * analysis.
  */
 class WorkItem {
   /**
    * The context in which the task will be performed.
    */
   final InternalAnalysisContext context;
 
   /**
-   * The alternative source of analysis results.
-   */
-  final ResultProvider resultProvider;
-
-  /**
    * The target for which a task is to be performed.
    */
   final AnalysisTarget target;
 
   /**
    * A description of the task to be performed.
    */
   final TaskDescriptor descriptor;
 
   /**
@@ skipping 42 matching lines @@
    * the set of [WorkItem]s contained in the cycle (if there are overlapping
    * cycles, this is the set of all [WorkItem]s in the entire strongly
    * connected component).  Otherwise, `null`.
    */
   List<WorkItem> dependencyCycle;
 
   /**
    * Initialize a newly created work item to compute the inputs for the task
    * described by the given descriptor.
    */
-  WorkItem(this.context, this.resultProvider, this.target, this.descriptor,
-      this.spawningResult, this.level, this.workOrder) {
+  WorkItem(this.context, this.target, this.descriptor, this.spawningResult,
+      this.level, this.workOrder) {
     AnalysisTarget actualTarget =
         identical(target, AnalysisContextTarget.request)
             ? new AnalysisContextTarget(context)
             : target;
 //    print('${'\t' * level}$spawningResult of $actualTarget');
     Map<String, TaskInput> inputDescriptors =
         descriptor.createTaskInputs(actualTarget);
     builder = new TopLevelTaskInputBuilder(inputDescriptors);
     if (!builder.moveNext()) {
       builder = null;
@@ skipping 83 matching lines @@
         // One possibility would be to return a WorkItem that would perform a
         // no-op task in order to cause us to come back to this work item on the
         // 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.
         //
         throw new UnimplementedError();
       } else if (inputState != CacheState.VALID) {
-        if (resultProvider != null &&
-            resultProvider.provideResult(context, inputEntry, inputResult)) {
+        if (context.aboutToComputeResult(inputEntry, inputResult)) {
           inputState = CacheState.VALID;
           builder.currentValue = inputEntry.getValue(inputResult);
         } else {
           try {
             TaskDescriptor descriptor =
                 taskManager.findTask(inputTarget, inputResult);
-            return new WorkItem(context, resultProvider, inputTarget,
-                descriptor, inputResult, level + 1, workOrder);
+            return new WorkItem(context, inputTarget, descriptor, inputResult,
+                level + 1, workOrder);
           } on AnalysisException catch (exception, stackTrace) {
             this.exception = new CaughtException(exception, stackTrace);
             return null;
           }
         }
       } else {
         builder.currentValue = inputEntry.getValue(inputResult);
         if (builder.flushOnAccess) {
           inputEntry.setState(inputResult, CacheState.FLUSHED);
         }
@@ skipping 90 matching lines @@
   final TaskManager taskManager;
 
   _WorkOrderDependencyWalker(this.taskManager, WorkItem startingNode)
       : super(startingNode);
 
   @override
   WorkItem getNextInput(WorkItem node, List<WorkItem> skipInputs) {
     return node.gatherInputs(taskManager, skipInputs);
   }
 }