Extension point for WorkManagerFactory(s).

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, AnalysisContextImpl;
+    hide AnalysisTask, AnalysisContextImpl, WorkManager;
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/utilities_general.dart';
 import 'package:analyzer/src/task/inputs.dart';
 import 'package:analyzer/src/task/manager.dart';
 import 'package:analyzer/task/model.dart';
 
 final PerformanceTag workOrderMoveNextPerfTag =
     new PerformanceTag('WorkOrder.moveNext');
 
@@ skipping 14 matching lines @@
   final List<WorkManager> workManagers;
 
   /**
    * The context in which analysis is to be performed.
    */
   final InternalAnalysisContext context;
 
   /**
    * The map of [ComputedResult] controllers.
    */
-  final Map<ResultDescriptor, StreamController<ComputedResult>> resultComputedControllers =
+  final Map<ResultDescriptor,
+          StreamController<ComputedResult>> resultComputedControllers =
       <ResultDescriptor, StreamController<ComputedResult>>{};
 
   /**
    * The work order that was previously computed but that has not yet been
    * completed.
    */
   WorkOrder currentWorkOrder;
 
   /**
    * Indicates whether any tasks are currently being performed (or building
@@ skipping 132 matching lines @@
       }
     }
     return null;
   }
 
   /**
    * Return the stream that is notified when a new value for the given
    * [descriptor] is computed.
    */
   Stream<ComputedResult> onResultComputed(ResultDescriptor descriptor) {
-    return resultComputedControllers.putIfAbsent(descriptor, () =>
-        new StreamController<ComputedResult>.broadcast(sync: true)).stream;
+    return resultComputedControllers
+        .putIfAbsent(descriptor,
+            () => new StreamController<ComputedResult>.broadcast(sync: true))
+        .stream;
   }
 
   /**
    * Perform the next analysis task, and return `true` if there is more work to
    * be done in order to compute all of the required analysis information.
    */
   bool performAnalysisTask() {
     //
     // TODO(brianwilkerson) This implementaiton does not allow us to prioritize
     // work across contexts. What we need is a way for an external client to ask
@@ skipping 257 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`.
    */
   final List<WorkItem> dependencyCycle;
 
   /**
    * 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) : super(
-          'Infinite loop while performing task ${task.descriptor.name} for ${task.target}');
+  InfiniteTaskLoopException(AnalysisTask task, this.dependencyCycle)
+      : super(
+            'Infinite loop while performing task ${task.descriptor.name} for ${task.target}');
 }
 
 /**
  * Object used by CycleAwareDependencyWalker to report a single strongly
  * connected component of nodes.
  */
 class StronglyConnectedComponent<Node> {
   /**
    * The nodes contained in the strongly connected component.
    */
@@ skipping 67 matching lines @@
    * 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.target, this.descriptor, this.spawningResult) {
-    AnalysisTarget actualTarget = identical(
-            target, AnalysisContextTarget.request)
-        ? new AnalysisContextTarget(context)
-        : target;
+    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>();
   }
 
   @override
@@ skipping 83 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 {
-  /**
-   * Notifies the managers that the given set of priority [targets] was set.
-   */
-  void applyPriorityTargets(List<AnalysisTarget> targets);
-
-  /**
-   * 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);
-}
-
-/**
  * 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 dependency walker which is being used to determine what work to do
    * next.
    */
   final _WorkOrderDependencyWalker _dependencyWalker;
 
@@ skipping 46 matching lines @@
         } else {
           assert(currentItems.length == 1);
         }
         return true;
       }
     });
   }
 }
 
 /**
- * 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
-}
-
-/**
  * Specilaization of [CycleAwareDependencyWalker] for use by [WorkOrder].
  */
 class _WorkOrderDependencyWalker extends CycleAwareDependencyWalker<WorkItem> {
   /**
    * The task manager used to build work items.
    */
   final TaskManager taskManager;
 
   _WorkOrderDependencyWalker(this.taskManager, WorkItem startingNode)
       : super(startingNode);
 
   @override
   WorkItem getNextInput(WorkItem node, List<WorkItem> skipInputs) {
     return node.gatherInputs(taskManager, skipInputs);
   }
 }