Add AnalysisContext.onResultInvalidated(descriptor).

pkg/analyzer/lib/src/generated/engine.dart

 // Copyright (c) 2014, 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.generated.engine;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 496 matching lines @@
    * reference 'dart:html', either directly or indirectly).
    *
    * <b>Note:</b> In addition to the expected case of returning `false` if the
    * source is known to be a library that cannot be run on the server, this
    * method will also return `false` if the source is not known to be a library
    * or if we do not know whether it can be run on the server.
    */
   bool isServerLibrary(Source librarySource);
 
   /**
+   * Return the stream that is notified when a result with the given
+   * [descriptor] is changed, e.g. computed or invalidated.
+   */
+  Stream<ResultChangedEvent> onResultChanged(ResultDescriptor descriptor);
+
+  /**
    * Return the stream that is notified when a new value for the given
    * [descriptor] is computed.
    */
+  @deprecated
   Stream<ComputedResult> onResultComputed(ResultDescriptor descriptor);
 
   /**
    * Parse the content of the given [source] to produce an AST structure. The
    * resulting AST structure may or may not be resolved, and may have a slightly
    * different structure depending upon whether it is resolved.
    *
    * Throws an [AnalysisException] if the analysis could not be performed
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    */
   CompilationUnit parseCompilationUnit(Source source);
 
   /**
    * Parse a single HTML [source] to produce a document model.
    *
    * Throws an [AnalysisException] if the analysis could not be performed
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    */
   Document parseHtmlDocument(Source source);
 
   /**
    * Perform the next unit of work required to keep the analysis results
    * up-to-date and return information about the consequent changes to the
    * analysis results. This method can be long running.
    *
    * The implementation that uses the task model notifies subscribers of
-   * [onResultComputed] about computed results.
+   * [onResultChanged] about computed results.
    *
    * The following results are computed for Dart sources.
    *
    * 1. For explicit and implicit sources:
    *    [PARSED_UNIT]
    *    [RESOLVED_UNIT]
    *
    * 2. For explicit sources:
    *    [DART_ERRORS].
    *
@@ skipping 1275 matching lines @@
    * number of characters in the original contents that were replaced. The
    * [newLength] is the number of characters in the replacement text.
    */
   ChangeSet_ContentChange(
       this.contents, this.offset, this.oldLength, this.newLength);
 }
 
 /**
  * [ComputedResult] describes a value computed for a [ResultDescriptor].
  */
+@deprecated
 class ComputedResult<V> {
   /**
    * The context in which the value was computed.
    */
   final AnalysisContext context;
 
   /**
    * The descriptor of the result which was computed.
    */
   final ResultDescriptor<V> descriptor;
 
   /**
    * The target for which the result was computed.
    */
   final AnalysisTarget target;
 
   /**
    * The computed value.
    */
   final V value;
 
   ComputedResult(this.context, this.descriptor, this.target, this.value);
 
   @override
-  String toString() => '$descriptor of $target in $context';
+  String toString() => 'Computed $descriptor of $target in $context';
 }
 
 /**
  * An event indicating when a source either starts or stops being implicitly
  * analyzed.
  */
 class ImplicitAnalysisEvent {
   /**
    * The source whose status has changed.
    */
@@ skipping 522 matching lines @@
    * Remove any resolution information from the given AST structure.
    */
   static void erase(AstNode node, {bool eraseDeclarations: true}) {
     ResolutionEraser eraser = new ResolutionEraser();
     eraser.eraseDeclarations = eraseDeclarations;
     node.accept(eraser);
   }
 }
 
 /**
+ * [ResultChangedEvent] describes a change to an analysis result.
+ */
+class ResultChangedEvent<V> {
+  /**
+   * The context in which the result was changed.
+   */
+  final AnalysisContext context;
+
+  /**
+   * The target for which the result was changed.
+   */
+  final AnalysisTarget target;
+
+  /**
+   * The descriptor of the result which was changed.
+   */
+  final ResultDescriptor<V> descriptor;
+
+  /**
+   * If the result [wasComputed], the new value of the result. If the result
+   * [wasInvalidated], the value of before it was invalidated, may be the
+   * default value if the result was flushed.
+   */
+  final V value;
+
+  /**
+   * Is `true` if the result was computed, or `false` is is was invalidated.
+   */
+  final bool _wasComputed;
+
+  ResultChangedEvent(this.context, this.target, this.descriptor, this.value,
+      this._wasComputed);
+
+  /**
+   * Returns `true` if the result was computed.
+   */
+  bool get wasComputed => _wasComputed;
+
+  /**
+   * Returns `true` if the result was invalidated.
+   */
+  bool get wasInvalidated => !_wasComputed;
+
+  @override
+  String toString() => '$descriptor of $target';

[Brian Wilkerson, 2016/03/08 20:47:02]

" in $context"?

[scheglov, 2016/03/08 20:53:46]

Done.

+}
+
+/**
  * [SourcesChangedEvent] indicates which sources have been added, removed,
  * or whose contents have changed.
  */
 class SourcesChangedEvent {
   /**
    * The internal representation of what has changed. Clients should not access
    * this field directly.
    */
   final ChangeSet _changeSet;
 
@@ skipping 58 matching lines @@
    * The data that was created from the source.
    */
   final E data;
 
   /**
    * Initialize a newly created holder to associate the given [data] with the
    * given [modificationTime].
    */
   TimestampedData(this.modificationTime, this.data);
 }