More fixes to the new analysis context implementation

pkg/analyzer/lib/src/context/context.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.context.context;
 
 import 'dart:async';
 import 'dart:collection';
 
 import 'package:analyzer/src/cancelable_future.dart';
@@ skipping 12 matching lines @@
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_collection.dart';
 import 'package:analyzer/src/task/dart.dart';
 import 'package:analyzer/src/task/driver.dart';
 import 'package:analyzer/src/task/manager.dart';
 import 'package:analyzer/task/dart.dart';
 import 'package:analyzer/task/general.dart';
 import 'package:analyzer/task/model.dart';
 
 /**
+ * Type of callback functions used by PendingFuture. Functions of this type
+ * should perform a computation based on the data in [entry] and return it. If
+ * the computation can't be performed yet because more analysis is needed,
+ * `null` should be returned.
+ *
+ * The function may also throw an exception, in which case the corresponding
+ * future will be completed with failure.
+ *
+ * Because this function is 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.
+ */
+typedef T PendingFutureComputer<T>(cache.CacheEntry entry);
+
+/**
  * An [AnalysisContext] in which analysis can be performed.
  */
 class AnalysisContextImpl implements InternalAnalysisContext {
   /**
    * A client-provided name used to identify this context, or `null` if the
    * client has not provided a name.
    */
   String name;
 
   /**
@@ skipping 47 matching lines @@
   /**
    * A list containing sources for which data should not be flushed.
    */
   List<Source> _priorityOrder = Source.EMPTY_ARRAY;
 
   /**
    * A map from all sources for which there are futures pending to a list of
    * the corresponding PendingFuture objects.  These sources will be analyzed
    * in the same way as priority sources, except with higher priority.
    */
-  HashMap<Source, List<PendingFuture>> _pendingFutureSources =
-      new HashMap<Source, List<PendingFuture>>();
+  HashMap<AnalysisTarget, List<PendingFuture>> _pendingFutureTargets =
+      new HashMap<AnalysisTarget, List<PendingFuture>>();
 
   /**
    * A table mapping sources to the change notices that are waiting to be
    * returned related to that source.
    */
   HashMap<Source, ChangeNoticeImpl> _pendingNotices =
       new HashMap<Source, ChangeNoticeImpl>();
 
   /**
    * Cached information used in incremental analysis or `null` if none.
@@ skipping 182 matching lines @@
   @override
   List<Source> get librarySources => _getSources(SourceKind.LIBRARY);
 
   @override
   Stream<SourcesChangedEvent> get onSourcesChanged =>
       _onSourcesChangedController.stream;
 
   /**
    * Make _pendingFutureSources available to unit tests.
    */
-  HashMap<Source, List<PendingFuture>> get pendingFutureSources_forTesting =>
-      _pendingFutureSources;
+  HashMap<AnalysisTarget, List<PendingFuture>> get pendingFutureSources_forTesting =>
+      _pendingFutureTargets;
 
   @override
   List<Source> get prioritySources => _priorityOrder;
 
   @override
   List<AnalysisTarget> get priorityTargets => prioritySources;
 
   @override
   SourceFactory get sourceFactory => _sourceFactory;
 
@@ skipping 94 matching lines @@
     return _typeProvider;
   }
 
   /**
    * Sets the [TypeProvider] for this context.
    */
   void set typeProvider(TypeProvider typeProvider) {
     _typeProvider = typeProvider;
   }
 
-  /**
-   * Return `true` if the (new) task model should be used to perform analysis.
-   */
-  bool get useTaskModel => AnalysisEngine.instance.useTaskModel;
-
   @override
   void addListener(AnalysisListener listener) {
     if (!_listeners.contains(listener)) {
       _listeners.add(listener);
     }
   }
 
   @override
   void addSourceInfo(Source source, SourceEntry info) {
     // TODO(brianwilkerson) This method needs to be replaced by something that
@@ skipping 124 matching lines @@
 
   @override
   @deprecated
   CompilationUnit computeResolvableCompilationUnit(Source source) {
     return null;
   }
 
   @override
   CancelableFuture<CompilationUnit> computeResolvedCompilationUnitAsync(
       Source unitSource, Source librarySource) {
-    // TODO(brianwilkerson) Implement this.
-    return new CancelableFuture<CompilationUnit>(() => null);
-//    return new _AnalysisFutureHelper<CompilationUnit>(this).computeAsync(
-//        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);
-//      }
-//      throw new AnalysisNotScheduledError();
-//    });
+    if (!AnalysisEngine.isDartFileName(unitSource.shortName) ||
+        !AnalysisEngine.isDartFileName(librarySource.shortName)) {
+      return new CancelableFuture.error(new AnalysisNotScheduledError());
+    }
+    return new _AnalysisFutureHelper<CompilationUnit>(this).computeAsync(
+        new LibrarySpecificUnit(librarySource, unitSource),
+        (cache.CacheEntry entry) {
+      CacheState state = entry.getState(RESOLVED_UNIT);
+      if (state == CacheState.ERROR) {
+        throw entry.exception;
+      } else if (state == CacheState.INVALID) {
+        return null;
+      }
+      return entry.getValue(RESOLVED_UNIT);
+    });
   }
 
   /**
    * Create an analysis cache based on the given source [factory].
    */
   cache.AnalysisCache createCacheFromSourceFactory(SourceFactory factory) {
     if (factory == null) {
       return new cache.AnalysisCache(<cache.CachePartition>[_privatePartition]);
     }
     DartSdk sdk = factory.dartSdk;
     if (sdk == null) {
       return new cache.AnalysisCache(<cache.CachePartition>[_privatePartition]);
     }
     return new cache.AnalysisCache(<cache.CachePartition>[
       AnalysisEngine.instance.partitionManager_new.forSdk(sdk),
       _privatePartition
     ]);
   }
 
   @override
   void dispose() {
     _disposed = true;
-    for (List<PendingFuture> pendingFutures in _pendingFutureSources.values) {
+    for (List<PendingFuture> pendingFutures in _pendingFutureTargets.values) {
       for (PendingFuture pendingFuture in pendingFutures) {
         pendingFuture.forciblyComplete();
       }
     }
-    _pendingFutureSources.clear();
+    _pendingFutureTargets.clear();
   }
 
   @override
   List<CompilationUnit> ensureResolvedDartUnits(Source unitSource) {
     // TODO(brianwilkerson) Implement this.
     return null;
 //    cache.CacheEntry entry = _cache.get(unitSource);
 //    // Check every library.
 //    List<CompilationUnit> units = <CompilationUnit>[];
 //    List<Source> containingLibraries = entry.containingLibraries;
@@ skipping 117 matching lines @@
       }
     } catch (exception) {
       // If the location cannot be decoded for some reason then the underlying
       // cause should have been logged already and we can fall though to return
       // null.
     }
     return null;
   }
 
   @override
-  AnalysisErrorInfo getErrors(Source source) => _getResult(source, DART_ERRORS);
+  AnalysisErrorInfo getErrors(Source source) {
+    List<AnalysisError> errors = _getResult(source, DART_ERRORS);
+    LineInfo lineInfo = _getResult(source, LINE_INFO);
+    return new AnalysisErrorInfoImpl(errors, lineInfo);
+  }
 
   @override
   HtmlElement getHtmlElement(Source source) {
     // TODO(brianwilkerson) Implement this.
 //    SourceEntry sourceEntry = getReadableSourceEntryOrNull(source);
 //    if (sourceEntry is HtmlEntry) {
 //      return sourceEntry.getValue(HtmlEntry.ELEMENT);
 //    }
     return null;
   }
@@ skipping 119 matching lines @@
   /**
    * Return the cache entry associated with the given [source], or `null` if
    * there is no entry associated with the source.
    */
   cache.CacheEntry getReadableSourceEntryOrNull(Source source) =>
       _cache.get(source);
 
   @override
   CompilationUnit getResolvedCompilationUnit(
       Source unitSource, LibraryElement library) {
-    if (library == null) {
+    if (library == null ||
+        !AnalysisEngine.isDartFileName(unitSource.shortName)) {
       return null;
     }
     return getResolvedCompilationUnit2(unitSource, library.source);
   }
 
   @override
   CompilationUnit getResolvedCompilationUnit2(
-      Source unitSource, Source librarySource) => _getResult(
-          new LibrarySpecificUnit(librarySource, unitSource), RESOLVED_UNIT);
+      Source unitSource, Source librarySource) {
+    if (!AnalysisEngine.isDartFileName(unitSource.shortName) ||
+        !AnalysisEngine.isDartFileName(librarySource.shortName)) {
+      return null;
+    }
+    return _getResult(
+        new LibrarySpecificUnit(librarySource, unitSource), RESOLVED_UNIT);
+  }
 
   @override
   ht.HtmlUnit getResolvedHtmlUnit(Source htmlSource) {
     // TODO(brianwilkerson) Implement this.
 //    SourceEntry sourceEntry = getReadableSourceEntryOrNull(htmlSource);
 //    if (sourceEntry is HtmlEntry) {
 //      HtmlEntry htmlEntry = sourceEntry;
 //      return htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT);
 //    }
     return null;
@@ skipping 196 matching lines @@
   CompilationUnit resolveCompilationUnit(
       Source unitSource, LibraryElement library) {
     if (library == null) {
       return null;
     }
     return resolveCompilationUnit2(unitSource, library.source);
   }
 
   @override
   CompilationUnit resolveCompilationUnit2(
-      Source unitSource, Source librarySource) => _computeResult(
-          new LibrarySpecificUnit(librarySource, unitSource), RESOLVED_UNIT);
+      Source unitSource, Source librarySource) {
+    if (!AnalysisEngine.isDartFileName(unitSource.shortName) ||
+        !AnalysisEngine.isDartFileName(librarySource.shortName)) {
+      return null;
+    }
+    return _computeResult(
+        new LibrarySpecificUnit(librarySource, unitSource), RESOLVED_UNIT);
+  }
 
   @override
   ht.HtmlUnit resolveHtmlUnit(Source htmlSource) {
     computeHtmlElement(htmlSource);
     return parseHtmlUnit(htmlSource);
   }
 
   @override
   void setChangedContents(Source source, String contents, int offset,
       int oldLength, int newLength) {
@@ skipping 11 matching lines @@
   @override
   void visitCacheItems(void callback(Source source, SourceEntry dartEntry,
       DataDescriptor rowDesc, CacheState state)) {
     // TODO(brianwilkerson) Figure out where this is used and adjust the call
     // sites to use CacheEntry's.
 //    bool hintsEnabled = _options.hint;
 //    bool lintsEnabled = _options.lint;
 //    MapIterator<AnalysisTarget, cache.CacheEntry> iterator = _cache.iterator();
 //    while (iterator.moveNext()) {
 //      Source source = iterator.key;
-//      cache.CacheEntry sourceEntry = iterator.value;
-//      for (DataDescriptor descriptor in sourceEntry.descriptors) {
+//      cache.CacheEntry entry = iterator.value;
+//      for (DataDescriptor descriptor in entry.descriptors) {
 //        if (descriptor == DartEntry.SOURCE_KIND) {
 //          // The source kind is always valid, so the state isn't interesting.
 //          continue;
 //        } else if (descriptor == DartEntry.CONTAINING_LIBRARIES) {
 //          // The list of containing libraries is always valid, so the state
 //          // isn't interesting.
 //          continue;
 //        } else if (descriptor == DartEntry.PUBLIC_NAMESPACE) {
 //          // The public namespace isn't computed by performAnalysisTask()
 //          // and therefore isn't interesting.
 //          continue;
 //        } else if (descriptor == HtmlEntry.HINTS) {
 //          // We are not currently recording any hints related to HTML.
 //          continue;
 //        }
 //        callback(
-//            source, sourceEntry, descriptor, sourceEntry.getState(descriptor));
+//            source, entry, descriptor, entry.getState(descriptor));
 //      }
-//      if (sourceEntry is DartEntry) {
+//      if (entry is DartEntry) {
 //        // get library-specific values
 //        List<Source> librarySources = getLibrariesContaining(source);
 //        for (Source librarySource in librarySources) {
-//          for (DataDescriptor descriptor in sourceEntry.libraryDescriptors) {
+//          for (DataDescriptor descriptor in entry.libraryDescriptors) {
 //            if (descriptor == DartEntry.BUILT_ELEMENT ||
 //                descriptor == DartEntry.BUILT_UNIT) {
 //              // These values are not currently being computed, so their state
 //              // is not interesting.
 //              continue;
-//            } else if (!sourceEntry.explicitlyAdded &&
+//            } else if (!entry.explicitlyAdded &&
 //                !_generateImplicitErrors &&
 //                (descriptor == DartEntry.VERIFICATION_ERRORS ||
 //                    descriptor == DartEntry.HINTS ||
 //                    descriptor == DartEntry.LINTS)) {
 //              continue;
 //            } else if (source.isInSystemLibrary &&
 //                !_generateSdkErrors &&
 //                (descriptor == DartEntry.VERIFICATION_ERRORS ||
 //                    descriptor == DartEntry.HINTS ||
 //                    descriptor == DartEntry.LINTS)) {
 //              continue;
 //            } else if (!hintsEnabled && descriptor == DartEntry.HINTS) {
 //              continue;
 //            } else if (!lintsEnabled && descriptor == DartEntry.LINTS) {
 //              continue;
 //            }
-//            callback(librarySource, sourceEntry, descriptor,
-//                sourceEntry.getStateInLibrary(descriptor, librarySource));
+//            callback(librarySource, entry, descriptor,
+//                entry.getStateInLibrary(descriptor, librarySource));
 //          }
 //        }
 //      }
 //    }
   }
 
   /**
    * Visit all entries of the content cache.
    */
   void visitContentCache(ContentCacheVisitor visitor) {
     _contentCache.accept(visitor);
   }
 
   /**
    * Add all of the sources contained in the given source [container] to the
    * given list of [sources].
    */
   void _addSourcesInContainer(List<Source> sources, SourceContainer container) {
     MapIterator<AnalysisTarget, cache.CacheEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       Source source = iterator.key;
       if (container.contains(source)) {
         sources.add(source);
       }
     }
   }
 
   /**
+   * Remove the given [pendingFuture] from [_pendingFutureTargets], since the
+   * client has indicated its computation is not needed anymore.
+   */
+  void _cancelFuture(PendingFuture pendingFuture) {
+    List<PendingFuture> pendingFutures =
+        _pendingFutureTargets[pendingFuture.target];
+    if (pendingFutures != null) {
+      pendingFutures.remove(pendingFuture);
+      if (pendingFutures.isEmpty) {
+        _pendingFutureTargets.remove(pendingFuture.target);
+      }
+    }
+  }
+
+  /**
    * Return the priority that should be used when the source associated with
    * the given [entry] is added to the work manager.
    */
   SourcePriority _computePriority(cache.CacheEntry entry) {
     // Used in commented out code.
     SourceKind kind = entry.getValue(SOURCE_KIND);
     if (kind == SourceKind.LIBRARY) {
       return SourcePriority.LIBRARY;
     } else if (kind == SourceKind.PART) {
       return SourcePriority.NORMAL_PART;
     }
     return SourcePriority.UNKNOWN;
   }
 
   Object /*V*/ _computeResult(
       AnalysisTarget target, ResultDescriptor /*<V>*/ descriptor) {
-    cache.CacheEntry entry = _cache.get(target);
-    if (entry == null) {
-      return descriptor.defaultValue;
-    }
+    cache.CacheEntry entry = getCacheEntry(target);
     if (descriptor is CompositeResultDescriptor) {
       List compositeResults = [];
       for (ResultDescriptor descriptor in descriptor.contributors) {
         List value = _computeResult(target, descriptor);
         compositeResults.addAll(value);
       }
       return compositeResults;
     }
     CacheState state = entry.getState(descriptor);
     if (state == CacheState.FLUSHED || state == CacheState.INVALID) {
       _driver.computeResult(target, descriptor);
     }
+    state = entry.getState(descriptor);
+    if (state == CacheState.ERROR) {
+      throw new AnalysisException(
+          'Cannot compute $descriptor for $target', entry.exception);
+    }
     return entry.getValue(descriptor);
   }
 
   /**
    * Given the encoded form of a source ([encoding]), use the source factory to
    * reconstitute the original source.
    */
   Source _computeSourceFromEncoding(String encoding) =>
       _sourceFactory.fromEncoding(encoding);
 
@@ skipping 110 matching lines @@
     ChangeNoticeImpl notice = _pendingNotices[source];
     if (notice == null) {
       notice = new ChangeNoticeImpl(source);
       _pendingNotices[source] = notice;
     }
     return notice;
   }
 
   Object _getResult(AnalysisTarget target, ResultDescriptor descriptor) {
     cache.CacheEntry entry = _cache.get(target);
-    if (entry != null && entry.isValid(descriptor)) {
+    if (entry == null) {
+      return descriptor.defaultValue;
+    }
+    if (descriptor is CompositeResultDescriptor) {
+      List compositeResults = [];
+      for (ResultDescriptor descriptor in descriptor.contributors) {
+        List value = _getResult(target, descriptor);
+        compositeResults.addAll(value);
+      }
+      return compositeResults;
+    }
+    if (entry.isValid(descriptor)) {
       return entry.getValue(descriptor);
     }
     return descriptor.defaultValue;
   }
 
   /**
    * Return a list containing all of the sources known to this context that have
    * the given [kind].
    */
   List<Source> _getSources(SourceKind kind) {
     List<Source> sources = new List<Source>();
     MapIterator<AnalysisTarget, cache.CacheEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       if (iterator.value.getValue(SOURCE_KIND) == kind &&
           iterator.key is Source) {
         sources.add(iterator.key);
       }
     }
     return sources;
   }
 
   /**
    * Look at the given [source] to see whether a task needs to be performed
    * related to it. If so, add the source to the set of sources that need to be
    * processed. This method is intended to be used for testing purposes only.
    */
-  void _getSourcesNeedingProcessing(Source source, cache.CacheEntry sourceEntry,
+  void _getSourcesNeedingProcessing(Source source, cache.CacheEntry entry,
       bool isPriority, bool hintsEnabled, bool lintsEnabled,
       HashSet<Source> sources) {
-    CacheState state = sourceEntry.getState(CONTENT);
+    CacheState state = entry.getState(CONTENT);
     if (state == CacheState.INVALID ||
         (isPriority && state == CacheState.FLUSHED)) {
       sources.add(source);
       return;
     } else if (state == CacheState.ERROR) {
       return;
     }
-    state = sourceEntry.getState(SOURCE_KIND);
+    state = entry.getState(SOURCE_KIND);
     if (state == CacheState.INVALID ||
         (isPriority && state == CacheState.FLUSHED)) {
       sources.add(source);
       return;
     } else if (state == CacheState.ERROR) {
       return;
     }
-    SourceKind kind = sourceEntry.getValue(SOURCE_KIND);
+    SourceKind kind = entry.getValue(SOURCE_KIND);
     if (kind == SourceKind.LIBRARY || kind == SourceKind.PART) {
-      state = sourceEntry.getState(SCAN_ERRORS);
+      state = entry.getState(SCAN_ERRORS);
       if (state == CacheState.INVALID ||
           (isPriority && state == CacheState.FLUSHED)) {
         sources.add(source);
         return;
       } else if (state == CacheState.ERROR) {
         return;
       }
-      state = sourceEntry.getState(PARSE_ERRORS);
+      state = entry.getState(PARSE_ERRORS);
       if (state == CacheState.INVALID ||
           (isPriority && state == CacheState.FLUSHED)) {
         sources.add(source);
         return;
       } else if (state == CacheState.ERROR) {
         return;
       }
 //      if (isPriority) {
-//        if (!sourceEntry.hasResolvableCompilationUnit) {
+//        if (!entry.hasResolvableCompilationUnit) {
 //          sources.add(source);
 //          return;
 //        }
 //      }
       for (Source librarySource in getLibrariesContaining(source)) {
         cache.CacheEntry libraryEntry = _cache.get(librarySource);
         state = libraryEntry.getState(LIBRARY_ELEMENT);
         if (state == CacheState.INVALID ||
             (isPriority && state == CacheState.FLUSHED)) {
           sources.add(source);
@@ skipping 36 matching lines @@
 //                (isPriority && state == CacheState.FLUSHED)) {
 //              sources.add(source);
 //              return;
 //            } else if (state == CacheState.ERROR) {
 //              return;
 //            }
 //          }
         }
       }
 //    } else if (kind == SourceKind.HTML) {
-//      CacheState parsedUnitState = sourceEntry.getState(HtmlEntry.PARSED_UNIT);
+//      CacheState parsedUnitState = entry.getState(HtmlEntry.PARSED_UNIT);
 //      if (parsedUnitState == CacheState.INVALID ||
 //          (isPriority && parsedUnitState == CacheState.FLUSHED)) {
 //        sources.add(source);
 //        return;
 //      }
 //      CacheState resolvedUnitState =
-//          sourceEntry.getState(HtmlEntry.RESOLVED_UNIT);
+//          entry.getState(HtmlEntry.RESOLVED_UNIT);
 //      if (resolvedUnitState == CacheState.INVALID ||
 //          (isPriority && resolvedUnitState == CacheState.FLUSHED)) {
 //        sources.add(source);
 //        return;
 //      }
     }
   }
 
   /**
    * Invalidate all of the resolution results computed by this context. The flag
@@ skipping 425 matching lines @@
     // Check cache for an existing partition.
     cache.SdkCachePartition partition = _sdkPartitions[sdk];
     if (partition == null) {
       partition =
           new cache.SdkCachePartition(sdkContext, _DEFAULT_SDK_CACHE_SIZE);
       _sdkPartitions[sdk] = partition;
     }
     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 target used by this computation to compute its value.
+   */
+  final AnalysisTarget target;
+
+  /**
+   * The function which implements the computation.
+   */
+  final PendingFutureComputer<T> _computeValue;
+
+  /**
+   * The completer that should be completed once the computation has succeeded.
+   */
+  CancelableCompleter<T> _completer;
+
+  PendingFuture(this._context, this.target, this._computeValue) {
+    _completer = new CancelableCompleter<T>(_onCancel);
+  }
+
+  /**
+   * Retrieve the future which will be completed when this object is
+   * successfully evaluated.
+   */
+  CancelableFuture<T> get future => _completer.future;
+
+  /**
+   * Execute [_computeValue], passing it the given [entry], 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
+   * in a microtask, so there is no danger of side effects occurring due to
+   * client callbacks.
+   */
+  bool evaluate(cache.CacheEntry entry) {
+    assert(!_completer.isCompleted);
+    try {
+      T result = _computeValue(entry);
+      if (result == null) {
+        return false;
+      } else {
+        _completer.complete(result);
+        return true;
+      }
+    } catch (exception, stackTrace) {
+      _completer.completeError(exception, stackTrace);
+      return true;
+    }
+  }
+
+  /**
+   * No further analysis updates are expected which affect this future, so
+   * 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);
+  }
+}
+
+/**
+ * A 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 [target] 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 [target], 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> computeAsync(
+      AnalysisTarget target, T computeValue(cache.CacheEntry entry)) {
+    if (_context.isDisposed) {
+      // No further analysis is expected, so return a future that completes
+      // immediately with AnalysisNotScheduledError.
+      return new CancelableFuture.error(new AnalysisNotScheduledError());
+    }
+    cache.CacheEntry entry = _context.getReadableSourceEntryOrNull(target);
+    if (entry == null) {
+      return new CancelableFuture.error(new AnalysisNotScheduledError());
+    }
+    PendingFuture pendingFuture =
+        new PendingFuture<T>(_context, target, computeValue);
+    if (!pendingFuture.evaluate(entry)) {
+      _context._pendingFutureTargets
+          .putIfAbsent(target, () => <PendingFuture>[])
+          .add(pendingFuture);
+    }
+    return pendingFuture.future;
+  }
+}