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<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 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]
+   *
+   * 2. For explicit sources:
+   *    [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<ComputedResult> 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 3502 matching lines @@
   /**
    * The partition manager being used to manage the shared partitions.
    */
   final newContext.PartitionManager partitionManager_new =
       new newContext.PartitionManager();
 
   /**
    * A flag indicating whether the (new) task model should be used to perform
    * analysis.
    */
-  bool useTaskModel = false;
+  bool useTaskModel = true;
 
   /**
    * The task manager used to manage the tasks used to analyze code.
    */
   TaskManager _taskManager;
 
   AnalysisEngine._();
 
   /**
    * Return the instrumentation service that is to be used by this analysis
@@ skipping 1433 matching lines @@
    * content of a source. The [contents] is the new contents of the source. The
    * [offse] ist the offset into the current contents. The [oldLength] is the
    * 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].
+ */
+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';
+}
+
+/**
  * A pair containing a library and a list of the (source, entry) pairs for
  * compilation units in the library.
  */
 class CycleBuilder_LibraryPair {
   /**
    * The library containing the compilation units.
    */
   ResolvableLibrary library;
 
   /**
@@ skipping 4517 matching lines @@
     PendingFuture pendingFuture =
         new PendingFuture<T>(_context, source, computeValue);
     if (!pendingFuture.evaluate(sourceEntry)) {
       _context._pendingFutureSources
           .putIfAbsent(source, () => <PendingFuture>[])
           .add(pendingFuture);
     }
     return pendingFuture.future;
   }
 }