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;
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
+import 'package:analyzer/src/generated/source.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';
+import 'package:analyzer/src/generated/error.dart';
 
 final PerformanceTag workOrderMoveNextPerfTag =
     new PerformanceTag('WorkOrder.moveNext');
 
 /**
  * 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 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 90 matching lines @@
 }
 
 /**
  * [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 manager about changes in the explicit source list.
+   */
+  void applyChange(List<Source> addedSources, List<Source> changedSources,
+      List<Source> removedSources);
+
+  /**
    * Notifies the managers that the given set of priority [targets] was set.
    */
   void applyPriorityTargets(List<AnalysisTarget> targets);
 
   /**
+   * Return a list of all of the errors associated with the given [source].
+   * The list of errors will be empty if the source is not known to the context
+   * or if there are no errors in the source. The errors contained in the list
+   * can be incomplete.
+   */
+  List<AnalysisError> getErrors(Source source);
+
+  /**
    * 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 about analysis options changes.
+   */
+  void onAnalysisOptionsChanged();
+
+  /**
+   * Notifies the manager about [SourceFactory] changes.
+   */
+  void onSourceFactoryChanged();
+
+  /**
    * 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.
@@ skipping 95 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);
   }
 }