Add AnalysisContext.onResultInvalidated(descriptor).

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 26 matching lines @@
    * compute.
    */
   final List<WorkManager> workManagers;
 
   /**
    * The context in which analysis is to be performed.
    */
   final InternalAnalysisContext context;
 
   /**
-   * The map of [ComputedResult] controllers.
+   * The map of [ResultChangedEvent] controllers.
    */
-  final Map<ResultDescriptor, StreamController<ComputedResult>>
+  final Map<ResultDescriptor, StreamController<ResultChangedEvent>>
       resultComputedControllers =
-      <ResultDescriptor, StreamController<ComputedResult>>{};
+      <ResultDescriptor, StreamController<ResultChangedEvent>>{};
 
   /**
    * 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
@@ skipping 139 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;
+  Stream<ResultChangedEvent> onResultComputed(ResultDescriptor descriptor) {
+    return resultComputedControllers.putIfAbsent(descriptor, () {
+      return new StreamController<ResultChangedEvent>.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 51 matching lines @@
       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<ComputedResult> controller =
+          StreamController<ResultChangedEvent> controller =
               resultComputedControllers[descriptor];
           if (controller != null) {
-            ComputedResult event =
-                new ComputedResult(context, descriptor, target, value);
+            ResultChangedEvent event = new ResultChangedEvent(
+                context, target, descriptor, value, true);
             controller.add(event);
           }
         });
         for (WorkManager manager in workManagers) {
           manager.resultsComputed(target, outputs);
         }
       } else {
         entry.setErrorState(task.caughtException, item.descriptor.results);
       }
     });
@@ skipping 530 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);
   }
 }