Add AnalysisContext.onResultComputed().

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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine;
 
 import 'dart:async';
@@ skipping 724 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 new value for the given
+   * [descriptor] is computed.
+   */
+  Stream<ResultComputedEvent> 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 an AST structure. The resulting
    * HTML 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.
    */
   ht.HtmlUnit parseHtmlUnit(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.
+   *
+   * The following results are computed for Dart sources.
+   *
+   * 1. For explicit and implicit sources:
+   *    [PARSED_UNIT]
+   *    [RESOLVED_UNIT_NO_CONSTANTS].
+   *
+   * 2. For explicit sources:
+   *    [RESOLVED_UNIT]
+   *    [DART_ERRORS].
+   *
+   * 3. For explicit and implicit library sources:
+   *    [LIBRARY_ELEMENT].
    */
   AnalysisResult performAnalysisTask();
 
   /**
    * Remove the given [listener] from the list of objects that are to be
    * notified when various analysis results are produced in this context.
    */
   void removeListener(AnalysisListener listener);
 
   /**
@@ skipping 1420 matching lines @@
     SourceEntry sourceEntry = _getReadableSourceEntry(librarySource);
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       return !dartEntry.getValue(DartEntry.IS_CLIENT) &&
           dartEntry.getValue(DartEntry.IS_LAUNCHABLE);
     }
     return false;
   }
 
   @override
+  Stream<ResultComputedEvent> onResultComputed(ResultDescriptor descriptor) {
+    throw new NotImplementedException('In not task-based AnalysisContext.');
+  }
+
+  @override
   CompilationUnit parseCompilationUnit(Source source) =>
       _getDartParseData2(source, DartEntry.PARSED_UNIT, null);
 
   @override
   ht.HtmlUnit parseHtmlUnit(Source source) =>
       _getHtmlParseData(source, HtmlEntry.PARSED_UNIT, null);
 
   @override
   AnalysisResult performAnalysisTask() {
     if (_TRACE_PERFORM_TASK) {
@@ skipping 8529 matching lines @@
     //
     _resolutionErrors = errorListener.getErrorsForSource(source);
     //
     // Remember the resolved unit.
     //
     _resolvedUnit = _unit;
   }
 }
 
 /**
+ * [ResultComputedEvent] describes a value computed for a [ResultDescriptor].
+ */
+class ResultComputedEvent<V> {

[Brian Wilkerson, 2015/06/11 16:44:44]

Perhaps "ComputedResult"?

[scheglov, 2015/06/11 17:43:25]

Done.

+  /**
+   * 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;
+
+  ResultComputedEvent(this.context, this.descriptor, this.target, this.value);
+
+  @override
+  String toString() => '$descriptor of $target in $context';
+}
+
+/**
  * The priority of data in the cache in terms of the desirability of retaining
  * some specified data about a specified source.
  */
 class RetentionPriority extends Enum<RetentionPriority> {
   /**
    * A priority indicating that a given piece of data can be removed from the
    * cache without reservation.
    */
   static const RetentionPriority LOW = const RetentionPriority('LOW', 0);
 
@@ skipping 944 matching lines @@
     PendingFuture pendingFuture =
         new PendingFuture<T>(_context, source, computeValue);
     if (!pendingFuture.evaluate(sourceEntry)) {
       _context._pendingFutureSources
           .putIfAbsent(source, () => <PendingFuture>[])
           .add(pendingFuture);
     }
     return pendingFuture.future;
   }
 }