Add AnalysisDriver.onResultComputed().

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/context/context.dart' show ResultComputedEvent;
 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/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 =
@@ skipping 14 matching lines @@
    * compute.
    */
   final List<WorkManager> workManagers;
 
   /**
    * The context in which analysis is to be performed.
    */
   final InternalAnalysisContext context;
 
   /**
+   * The map of [ResultComputedEvent] controllers.
+   */
+  final Map<ResultDescriptor, StreamController<ResultComputedEvent>> resultComputedControllers =
+      <ResultDescriptor, StreamController<ResultComputedEvent>>{};
+
+  /**
    * 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
    * their inputs).  In debug builds, we use this to ensure that tasks don't
    * try to make use of the task manager in reentrant fashion.
    */
@@ skipping 125 matching lines @@
         WorkOrder workOrder = createWorkOrderForResult(target, result);
         if (workOrder != null) {
           return workOrder;
         }
       }
     }
     return null;
   }
 
   /**
+   * Return the stream that is notified when a new value for the given
+   * [descriptor] is computed.
+   */
+  Stream<ResultComputedEvent> onResultComputed(ResultDescriptor descriptor) {
+    return resultComputedControllers.putIfAbsent(descriptor, () =>
+        new StreamController<ResultComputedEvent>.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
     // to have all priority files analyzed for each context, then ask for normal
     // files to be analyzed. There are a couple of ways to do this.
     //
@@ skipping 36 matching lines @@
       // 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);
+    AnalysisTarget target = task.target;
+    CacheEntry entry = context.getCacheEntry(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);
       }
+      outputs.forEach((ResultDescriptor descriptor, value) {
+        StreamController<ResultComputedEvent> controller =
+            resultComputedControllers[descriptor];
+        if (controller != null) {
+          ResultComputedEvent event =
+              new ResultComputedEvent(context, descriptor, target, value);
+          controller.add(event);
+        }
+      });
       for (WorkManager manager in workManagers) {
-        manager.resultsComputed(task.target, outputs);
+        manager.resultsComputed(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
@@ skipping 516 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);
   }
 }