Make futures returned by AnalysisContext cancelable.

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:math" as math;
 import 'dart:async';
 import 'dart:collection';
 
+import 'package:analyzer/src/cancelable_future.dart';
 import 'package:analyzer/src/task/task_dart.dart';
 
 import '../../instrumentation/instrumentation.dart';
 import 'ast.dart';
 import 'constant.dart';
 import 'element.dart';
 import 'error.dart';
 import 'error_verifier.dart';
 import 'html.dart' as ht;
 import 'incremental_resolver.dart' show IncrementalResolver,
@@ skipping 727 matching lines @@
    * Return a future which will be completed with the fully resolved AST for a
    * single compilation unit within the given library, once that AST is up to
    * date.
    *
    * If the resolved AST can't be computed for some reason, the future will be
    * completed with an error.  One possible error is AnalysisNotScheduledError,
    * which means that the resolved AST can't be computed because the given
    * source file is not scheduled to be analyzed within the context of the
    * given library.
    */
-  Future<CompilationUnit> getResolvedCompilationUnitFuture(Source source,
-      Source librarySource);
+  CancelableFuture<CompilationUnit>
+      getResolvedCompilationUnitFuture(Source source, Source librarySource);
 
   /**
    * Return a fully resolved HTML unit, or `null` if the resolved unit is not already
    * computed.
    *
    * @param htmlSource the source of the HTML unit
    * @return a fully resolved HTML unit
    * See [resolveHtmlUnit].
    */
   ht.HtmlUnit getResolvedHtmlUnit(Source htmlSource);
@@ skipping 546 matching lines @@
       // to complete.
       return WaitForAsyncTask.instance;
     }
     return null;
   }
 
   @override
   Stream<SourcesChangedEvent> get onSourcesChanged =>
       _onSourcesChangedController.stream;
 
+  /**
+   * Make _pendingFutureSources available to unit tests.
+   */
+  HashMap<Source, List<PendingFuture>> get pendingFutureSources_forTesting =>
+      _pendingFutureSources;
+
   @override
   List<Source> get prioritySources => _priorityOrder;
 
   @override
   List<Source> get refactoringUnsafeSources {
     List<Source> sources = new List<Source>();
     MapIterator<Source, SourceEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       SourceEntry sourceEntry = iterator.value;
       if (sourceEntry is DartEntry) {
@@ skipping 729 matching lines @@
     SourceEntry sourceEntry = getReadableSourceEntryOrNull(unitSource);
     if (sourceEntry is DartEntry) {
       return sourceEntry.getValueInLibrary(
           DartEntry.RESOLVED_UNIT,
           librarySource);
     }
     return null;
   }
 
   @override
-  Future<CompilationUnit> getResolvedCompilationUnitFuture(Source unitSource,
-      Source librarySource) {
-    return _getFuture(unitSource, (SourceEntry sourceEntry) {
+  CancelableFuture<CompilationUnit>
+      getResolvedCompilationUnitFuture(Source unitSource, Source librarySource) {
+    return new _AnalysisFutureHelper<CompilationUnit>(
+        this).getFuture(unitSource, (SourceEntry sourceEntry) {
       if (sourceEntry is DartEntry) {
         if (sourceEntry.getStateInLibrary(
             DartEntry.RESOLVED_UNIT,
             librarySource) ==
             CacheState.ERROR) {
           throw sourceEntry.exception;
         }
         return sourceEntry.getValueInLibrary(
             DartEntry.RESOLVED_UNIT,
             librarySource);
@@ skipping 784 matching lines @@
           source,
           htmlEntry.modificationTime,
           htmlEntry.getValue(
               HtmlEntry.PARSED_UNIT)).perform(_resultRecorder) as HtmlEntry;
       state = htmlEntry.getState(descriptor);
     }
     return htmlEntry;
   }
 
   /**
+   * Remove the given [pendingFuture] from [_pendingFutureSources], since the
+   * client has indicated its computation is not needed anymore.
+   */
+  void _cancelFuture(PendingFuture pendingFuture) {
+    List<PendingFuture> pendingFutures =
+        _pendingFutureSources[pendingFuture.source];
+    if (pendingFutures != null) {
+      pendingFutures.remove(pendingFuture);
+      if (pendingFutures.isEmpty) {
+        _pendingFutureSources.remove(pendingFuture.source);
+      }
+    }
+  }
+
+  /**
    * Compute the transitive closure of all libraries that depend on the given library by adding such
    * libraries to the given collection.
    *
    * @param library the library on which the other libraries depend
    * @param librariesToInvalidate the libraries that depend on the given library
    */
   void _computeAllLibrariesDependingOn(Source library,
       HashSet<Source> librariesToInvalidate) {
     if (librariesToInvalidate.add(library)) {
       for (Source dependentLibrary in getLibrariesDependingOn(library)) {
@@ skipping 725 matching lines @@
    *           resolved
    */
   Object _getDartVerificationData(Source unitSource, Source librarySource,
       DartEntry dartEntry, DataDescriptor descriptor) {
     dartEntry =
         _cacheDartVerificationData(unitSource, librarySource, dartEntry, descriptor);
     return dartEntry.getValueInLibrary(descriptor, librarySource);
   }
 
   /**
-   * Return a future that will be completed with the result of calling
-   * [computeValue].  If [computeValue] returns non-null, the future will be
-   * completed immediately with the resulting value.  If it returns null, then
-   * it will be re-executed in the future, after the next time the cached
-   * information for [source] has changed.  If [computeValue] throws an
-   * exception, the future will fail with that exception.
-   *
-   * If the [computeValue] still returns null after there is no further
-   * analysis to be done for [source], then the future will be completed with
-   * the error AnalysisNotScheduledError.
-   *
-   * Since [computeValue] will be called while the state of analysis is being
-   * updated, it should be free of side effects so that it doesn't cause
-   * reentrant changes to the analysis state.
-   */
-  Future /*<T>*/ _getFuture(Source source, /*T*/
-  computeValue(SourceEntry sourceEntry)) {
-    SourceEntry sourceEntry = getReadableSourceEntryOrNull(source);
-    if (sourceEntry == null) {
-      return new Future.error(new AnalysisNotScheduledError());
-    }
-    PendingFuture pendingFuture = new PendingFuture(computeValue);
-    if (!pendingFuture.evaluate(sourceEntry)) {
-      _pendingFutureSources.putIfAbsent(
-          source,
-          () => <PendingFuture>[]).add(pendingFuture);
-    }
-    return pendingFuture.future;
-  }
-
-  /**
    * Given a source for an HTML file, return the data represented by the given descriptor that is
    * associated with that source, or the given default value if the source is not an HTML file. This
    * method assumes that the data can be produced by parsing the source if it is not already cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @param defaultValue the value to be returned if the source is not an HTML file
    * @return the requested data about the given source
@@ skipping 5981 matching lines @@
   /**
    * Initialize a newly created descriptor to have the given [name] and
    * [defaultValue].
    */
   DataDescriptor(this._name, [this.defaultValue = null]);
 
   @override
   String toString() => _name;
 }
 
-
 /**
  * Instances of the class `DefaultRetentionPolicy` implement a retention policy that will keep
  * AST's in the cache if there is analysis information that needs to be computed for a source, where
  * the computation is dependent on having the AST.
  */
 class DefaultRetentionPolicy implements CacheRetentionPolicy {
   /**
    * An instance of this class that can be shared.
    */
   static DefaultRetentionPolicy POLICY = new DefaultRetentionPolicy();
@@ skipping 15 matching lines @@
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       if (astIsNeeded(dartEntry)) {
         return RetentionPriority.MEDIUM;
       }
     }
     return RetentionPriority.LOW;
   }
 }
 
+
 /**
  * Recursively visits [HtmlUnit] and every embedded [Expression].
  */
 abstract class ExpressionVisitor extends ht.RecursiveXmlVisitor<Object> {
   /**
    * Visits the given [Expression]s embedded into tag or attribute.
    *
    * @param expression the [Expression] to visit, not `null`
    */
   void visitExpression(Expression expression);
@@ skipping 1955 matching lines @@
     return partition;
   }
 }
 
 /**
  * Representation of a pending computation which is based on the results of
  * analysis that may or may not have been completed.
  */
 class PendingFuture<T> {
   /**
+   * The context in which this computation runs.
+   */
+  final AnalysisContextImpl _context;
+
+  /**
+   * The source used by this computation to compute its value.
+   */
+  final Source source;
+
+  /**
    * The function which implements the computation.
    */
   final PendingFutureComputer<T> _computeValue;
 
   /**
    * The completer that should be completed once the computation has succeeded.
    */
-  final Completer<T> _completer = new Completer<T>();
+  CancelableCompleter<T> _completer;
 
-  PendingFuture(this._computeValue);
+  PendingFuture(this._context, this.source, this._computeValue) {
+    _completer = new CancelableCompleter<T>(_onCancel);
+  }
 
   /**
    * Retrieve the future which will be completed when this object is
    * successfully evaluated.
    */
-  Future<T> get future => _completer.future;
+  CancelableFuture<T> get future => _completer.future;
 
   /**
    * Execute [_computeValue], passing it the given [sourceEntry], and complete
    * the pending future if it's appropriate to do so.  If the pending future is
    * completed by this call, true is returned; otherwise false is returned.
    *
    * Once this function has returned true, it should not be called again.
    *
    * Other than completing the future, this method is free of side effects.
    * Note that any code the client has attached to the future will be executed
@@ skipping 21 matching lines @@
    * complete it with an AnalysisNotScheduledError in order to avoid
    * deadlocking the client.
    */
   void forciblyComplete() {
     try {
       throw new AnalysisNotScheduledError();
     } catch (exception, stackTrace) {
       _completer.completeError(exception, stackTrace);
     }
   }
+
+  void _onCancel() {
+    _context._cancelFuture(this);
+  }
 }
 
 /**
  * Container with global [AnalysisContext] performance statistics.
  */
 class PerformanceStatistics {
   /**
    * The [TimeCounter] for time spent in reading files.
    */
   static TimeCounter io = new TimeCounter();
@@ skipping 2572 matching lines @@
       _index = 0;
       _queueIndex++;
       while (_queueIndex < _manager._workQueues.length &&
           _manager._workQueues[_queueIndex].isEmpty) {
         _queueIndex++;
       }
     }
   }
 }
 
+/**
+ * Helper class used to create futures for AnalysisContextImpl.  Using a helper
+ * class allows us to preserve the generic parameter T.
+ */
+class _AnalysisFutureHelper<T> {
+  final AnalysisContextImpl _context;
+
+  _AnalysisFutureHelper(this._context);
+
+  /**
+   * Return a future that will be completed with the result of calling
+   * [computeValue].  If [computeValue] returns non-null, the future will be
+   * completed immediately with the resulting value.  If it returns null, then
+   * it will be re-executed in the future, after the next time the cached
+   * information for [source] has changed.  If [computeValue] throws an
+   * exception, the future will fail with that exception.
+   *
+   * If the [computeValue] still returns null after there is no further
+   * analysis to be done for [source], then the future will be completed with
+   * the error AnalysisNotScheduledError.
+   *
+   * Since [computeValue] will be called while the state of analysis is being
+   * updated, it should be free of side effects so that it doesn't cause
+   * reentrant changes to the analysis state.
+   */
+  CancelableFuture<T> getFuture(Source source, T
+      computeValue(SourceEntry sourceEntry)) {
+    SourceEntry sourceEntry = _context.getReadableSourceEntryOrNull(source);
+    if (sourceEntry == null) {
+      return new CancelableFuture.error(new AnalysisNotScheduledError());
+    }
+    PendingFuture pendingFuture =
+        new PendingFuture<T>(_context, source, computeValue);
+    if (!pendingFuture.evaluate(sourceEntry)) {
+      _context._pendingFutureSources.putIfAbsent(
+          source,
+          () => <PendingFuture>[]).add(pendingFuture);
+    }
+    return pendingFuture.future;
+  }
+}
+
 class _AngularHtmlUnitResolver_visitModelDirectives extends
     ht.RecursiveXmlVisitor<Object> {
   final AngularHtmlUnitResolver resolver;
 
   _AngularHtmlUnitResolver_visitModelDirectives(this.resolver)
       : super();
 
   @override
   Object visitXmlTagNode(ht.XmlTagNode node) {
     NgModelProcessor directive = NgModelProcessor.INSTANCE;
@@ skipping 32 matching lines @@
 
   @override
   Object visitPolymerTagDartElement(PolymerTagDartElement element) {
     if (element.name == PolymerHtmlUnitBuilder_this._elementName) {
       throw new PolymerHtmlUnitBuilder_FoundTagDartElementError(
           element as PolymerTagDartElementImpl);
     }
     return null;
   }
 }