In the new task model, use explicit dependencies on the type provider.

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 189 matching lines @@
       currentWorkOrder = createNextWorkOrder();
     }
     return currentWorkOrder != null;
   }
 
   /**
    * Perform the given work item.
    * Return the performed [AnalysisTask].
    */
   AnalysisTask performWorkItem(WorkItem item) {
-    if (item.exception != null) {
-      // Mark all of the results that the task would have computed as being in
-      // ERROR with the exception recorded on the work item.
-      CacheEntry targetEntry = context.getCacheEntry(item.target);
-      targetEntry.setErrorState(item.exception, item.descriptor.results);
-      return null;
+    try {

[Paul Berry, 2015/05/13 21:32:00]

Note: it's not obvious from the diff, but the only non-whitespace changes to the
file are the addition of the try/finally blocks to this method and to the
gatherInputs() method.

+      assert(!taskManager.isTaskRunning);
+      taskManager.isTaskRunning = true;
+      if (item.exception != null) {
+        // Mark all of the results that the task would have computed as being in
+        // ERROR with the exception recorded on the work item.
+        CacheEntry targetEntry = context.getCacheEntry(item.target);
+        targetEntry.setErrorState(item.exception, item.descriptor.results);
+        return null;
+      }
+      // Otherwise, perform the task.
+      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);
+        }
+        for (WorkManager manager in workManagers) {
+          manager.resultsComputed(task.target, outputs);
+        }
+      } else {
+        entry.setErrorState(task.caughtException, item.descriptor.results);
+      }
+      _onTaskCompletedController.add(task);
+      return task;
+    } finally {
+      taskManager.isTaskRunning = false;
     }
-    // Otherwise, perform the task.
-    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);
-      }
-      for (WorkManager manager in workManagers) {
-        manager.resultsComputed(task.target, outputs);
-      }
-    } 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
    * or more analysis targets. This will cause any analysis that was currently
    * in process to be stopped and for analysis to resume based on the new state.
    */
   void reset() {
     currentWorkOrder = null;
   }
@@ skipping 108 matching lines @@
    *
    * If all of the inputs have been gathered, return `null` to indicate that the
    * client should build and perform the task. A value of `null` will also be
    * returned if some of the inputs cannot be computed and the task cannot be
    * performed. Callers can differentiate between these cases by checking the
    * [exception] field. If the field is `null`, then the task can be performed;
    * if the field is non-`null` then the task cannot be performed and all of the
    * tasks' results should be marked as being in ERROR.
    */
   WorkItem gatherInputs(TaskManager taskManager) {
-    while (builder != null) {
-      AnalysisTarget inputTarget = builder.currentTarget;
-      ResultDescriptor inputResult = builder.currentResult;
-      inputTargetedResults.add(new TargetedResult(inputTarget, inputResult));
-      CacheEntry inputEntry = context.getCacheEntry(inputTarget);
-      CacheState inputState = inputEntry.getState(inputResult);
-      if (inputState == CacheState.ERROR) {
-        exception = inputEntry.exception;
-        return null;
-      } else if (inputState == CacheState.IN_PROCESS) {
-        //
-        // TODO(brianwilkerson) Implement this case.
-        //
-        // 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.
-        //
-      } else if (inputState != CacheState.VALID) {
-        try {
-          TaskDescriptor descriptor =
-              taskManager.findTask(inputTarget, inputResult);
-          return new WorkItem(context, inputTarget, descriptor);
-        } on AnalysisException catch (exception, stackTrace) {
-          this.exception = new CaughtException(exception, stackTrace);
+    try {
+      assert(!taskManager.isTaskRunning);
+      taskManager.isTaskRunning = true;
+      while (builder != null) {
+        AnalysisTarget inputTarget = builder.currentTarget;
+        ResultDescriptor inputResult = builder.currentResult;
+        inputTargetedResults.add(new TargetedResult(inputTarget, inputResult));
+        CacheEntry inputEntry = context.getCacheEntry(inputTarget);
+        CacheState inputState = inputEntry.getState(inputResult);
+        if (inputState == CacheState.ERROR) {
+          exception = inputEntry.exception;
           return null;
+        } else if (inputState == CacheState.IN_PROCESS) {
+          //
+          // TODO(brianwilkerson) Implement this case.
+          //
+          // 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.
+          //
+        } else if (inputState != CacheState.VALID) {
+          try {
+            TaskDescriptor descriptor =
+                taskManager.findTask(inputTarget, inputResult);
+            return new WorkItem(context, inputTarget, descriptor);
+          } 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;
         }
       }
-      builder.currentValue = inputEntry.getValue(inputResult);
-      if (!builder.moveNext()) {
-        inputs = builder.inputValue;
-        builder = null;
-      }
+      return null;
+    } finally {
+      taskManager.isTaskRunning = false;
     }
-    return null;
   }
 
   @override
   String toString() => 'Run $descriptor on $target';
 }
 
 /**
  * [AnalysisDriver] uses [WorkManager]s to select results to compute.
  *
  * They know specific of the targets and results they care about,
@@ skipping 121 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;
   }
 }