Use WorkManager(s) in AnalysisDriver.

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';
 import 'package:analyzer/src/generated/engine.dart' hide AnalysisTask;
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/task/inputs.dart';
 import 'package:analyzer/src/task/manager.dart';
 import 'package:analyzer/task/model.dart';
 
 /**
  * An object that is used to cause analysis to be performed until all of the
  * required analysis information has been computed.
  */
 class AnalysisDriver {
   /**
    * The task manager used to figure out how to compute analysis results.
    */
   final TaskManager taskManager;
 
-//  /**
-//   * The list of [WorkManager] used to figure out which analysis results to
-//   * compute.
-//   */
-//  final List<WorkManager> workManagers;
+  /**
+   * The list of [WorkManager] used to figure out which analysis results to
+   * compute.
+   */
+  final List<WorkManager> workManagers;
 
   /**
    * The context in which analysis is to be performed.
    */
   final InternalAnalysisContext context;
 
   /**
    * The work order that was previously computed but that has not yet been
    * completed.
    */
   WorkOrder currentWorkOrder;
 
   /**
    * The controller that is notified when a task is started.
    */
   StreamController<AnalysisTask> _onTaskStartedController;
 
   /**
    * The controller that is notified when a task is complete.
    */
   StreamController<AnalysisTask> _onTaskCompletedController;
 
   /**
    * Initialize a newly created driver to use the tasks know to the given
    * [taskManager] to perform analysis in the given [context].
    */
-  AnalysisDriver(this.taskManager, this.context) {
+  AnalysisDriver(this.taskManager, this.workManagers, this.context) {
     _onTaskStartedController = new StreamController.broadcast();
     _onTaskCompletedController = new StreamController.broadcast();
   }
 
   /**
    * The stream that is notified when a task is complete.
    */
   Stream<AnalysisTask> get onTaskCompleted => _onTaskCompletedController.stream;
 
   /**
@@ skipping 14 matching lines @@
       }
     }
     return task;
   }
 
   /**
    * Return the work order describing the work that should be getting worked on,
    * or `null` if there is currently no work to be done.
    */
   WorkOrder createNextWorkOrder() {
-    //
-    // TODO(brianwilkerson) This is an inefficient implementation. We need to
-    // port over the concept of the WorkManager to manage the list of sources
-    // for which some work needs to be performed so that we do not waste time
-    // repeatedly looking at the same completed sources to see whether there is
-    // work that needs to be done.
-    //
-    for (AnalysisTarget target in context.priorityTargets) {
-      WorkOrder workOrder = createWorkOrderForTarget(target, true);
-      if (workOrder != null) {
-        return workOrder;
+    while (true) {
+      // Find the WorkManager with the highest priority.
+      WorkOrderPriority highestPriority = null;
+      WorkManager highestManager = null;
+      for (WorkManager manager in workManagers) {
+        WorkOrderPriority priority = manager.getNextResultPriority();
+        if (highestPriority == null || highestPriority.index > priority.index) {
+          highestPriority = priority;
+          highestManager = manager;
+        }
+      }
+      // Nothing to do.
+      if (highestPriority == WorkOrderPriority.NONE) {
+        return null;
+      }
+      // Create a new WorkOrder.
+      TargetedResult request = highestManager.getNextResult();
+      if (request != null) {
+        WorkOrder workOrder =
+            createWorkOrderForResult(request.target, request.result);
+        if (workOrder != null) {
+          return workOrder;
+        }
       }
     }
-    // TODO(brianwilkerson) Add a third priority, corresponding to
-    // AnalysisContextImpl._pendingFutureSources to support code completion.
-    for (AnalysisTarget target in context.explicitTargets) {
-      WorkOrder workOrder = createWorkOrderForTarget(target, false);
-      if (workOrder != null) {
-        return workOrder;
-      }
-    }
-    return null;
   }
 
   /**
    * Create a work order that will produce the given [result] for the given
    * [target]. Return the work order that was created, or `null` if the result
    * has already been computed.
    */
   WorkOrder createWorkOrderForResult(
       AnalysisTarget target, ResultDescriptor result) {
     CacheEntry entry = context.getCacheEntry(target);
@@ skipping 91 matching lines @@
     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
@@ skipping 158 matching lines @@
       }
     }
     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,
+ * so they can request analysis results in optimal order.
+ */
+abstract class WorkManager {
+  /**
+   * Return the next [TargetedResult] that this work manager wants to be
+   * computed, or `null` if this manager doesn't need any new results.
+   */
+  TargetedResult getNextResult();
+
+  /**
+   * Return the priority if the next work order this work manager want to be
+   * computed. The [AnalysisDriver] will perform the work order with
+   * the highest priority.
+   *
+   * Even if the returned value is [WorkOrderPriority.NONE], it still does not
+   * guarantee that [getNextResult] will return not `null`.
+   */
+  WorkOrderPriority getNextResultPriority();
+
+  /**
+   * Notifies the manager that the given [outputs] were produced for
+   * the given [target].
+   */
+  void resultsComputed(
+      AnalysisTarget target, Map<ResultDescriptor, dynamic> outputs);
+}
+
+/**
+ * The priorities of work orders returned by [WorkManager]s.
+ */
+enum WorkOrderPriority {
+  /**
+   * Responding to an user's action.
+   */
+  INTERACTIVE,
+
+  /**
+   * Computing information for priority sources.
+   */
+  PRIORITY,
+
+  /**
+   * A work should be done, but without any special urgency.
+   */
+  NORMAL,
+
+  /**
+   * Nothing to do.
+   */
+  NONE
+}
+
+/**
  * A description of the work to be done to compute a desired analysis result.
  * The class implements a lazy depth-first traversal of the work item's input.
  */
 class WorkOrder implements Iterator<WorkItem> {
   /**
    * The task manager used to build work items.
    */
   final TaskManager taskManager;
 
   /**
@@ skipping 53 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;
   }
 }
-
-/**
- * [AnalysisDriver] uses [WorkManager]s to select results to compute.
- *
- * They know specific of the targets and results they care about,
- * so they can request analysis results in optimal order.
- */
-abstract class WorkManager {
-  /**
-   * Return the next [TargetedResult] that this work manager wants to be
-   * computed, or `null` if this manager doesn't need any new results.
-   */
-  TargetedResult getNextResult();
-
-  /**
-   * Notifies the manager that the given [outputs] were produced for
-   * the given [target].
-   */
-  void resultsComputed(
-      AnalysisTarget target, Map<ResultDescriptor, dynamic> outputs);
-}