Fix for computeResolvedCompilationUnitAsync().

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/instrumentation/instrumentation.dart';
@@ skipping 590 matching lines @@
     return null;
   }
 
   @override
   CancelableFuture<CompilationUnit> computeResolvedCompilationUnitAsync(
       Source unitSource, Source librarySource) {
     if (!AnalysisEngine.isDartFileName(unitSource.shortName) ||
         !AnalysisEngine.isDartFileName(librarySource.shortName)) {
       return new CancelableFuture.error(new AnalysisNotScheduledError());
     }
+    var unitTarget = new LibrarySpecificUnit(librarySource, unitSource);
     return new _AnalysisFutureHelper<CompilationUnit>(this).computeAsync(
-        new LibrarySpecificUnit(librarySource, unitSource), (CacheEntry entry) {
+        unitTarget, (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);
+    }, () {
+      dartWorkManager.addPriorityResult(unitTarget, RESOLVED_UNIT);
     });
   }
 
   /**
    * Create an analysis cache based on the given source [factory].
    */
   AnalysisCache createCacheFromSourceFactory(SourceFactory factory) {
     if (factory == null) {
       return new AnalysisCache(<CachePartition>[_privatePartition]);
     }
@@ skipping 262 matching lines @@
     // Note that this is not part of the API of the interface.
     // TODO(brianwilkerson) The public namespace used to be cached, but no
     // longer is. Konstantin adds:
     // The only client of this method is NamespaceBuilder._createExportMapping(),
     // and it is not used with tasks - instead we compute export namespace once
     // using BuildExportNamespaceTask and reuse in scopes.
     NamespaceBuilder builder = new NamespaceBuilder();
     return builder.createPublicNamespaceForLibrary(library);
   }
 
-  /**
-   * Return the cache entry associated with the given [target], or `null` if
-   * there is no entry associated with the target.
-   */
-  CacheEntry getReadableSourceEntryOrNull(AnalysisTarget target) =>
-      _cache.get(target);
-
   @override
   CompilationUnit getResolvedCompilationUnit(
       Source unitSource, LibraryElement library) {
     if (library == null ||
         !AnalysisEngine.isDartFileName(unitSource.shortName)) {
       return null;
     }
     return getResolvedCompilationUnit2(unitSource, library.source);
   }
 
@@ skipping 119 matching lines @@
     if (!AnalysisEngine.isHtmlFileName(source.shortName)) {
       return null;
     }
     // TODO(brianwilkerson) Implement HTML analysis.
     return null; //_computeResult(source, null);
   }
 
   @override
   AnalysisResult performAnalysisTask() {
     return PerformanceStatistics.performAnaysis.makeCurrentWhile(() {
+      _evaluatePendingFutures();
       bool done = !driver.performAnalysisTask();
       if (done) {
         done = !_validateCacheConsistency();
       }
       List<ChangeNotice> notices = _getChangeNotices(done);
       if (notices != null) {
         int noticeCount = notices.length;
         for (int i = 0; i < noticeCount; i++) {
           ChangeNotice notice = notices[i];
           _notifyErrors(notice.source, notice.errors, notice.lineInfo);
         }
       }
       return new AnalysisResult(notices, -1, '', -1);
     });
   }
 
+  void _evaluatePendingFutures() {
+    for (AnalysisTarget target in _pendingFutureTargets.keys) {
+      CacheEntry cacheEntry = _cache.get(target);
+      List<PendingFuture> pendingFutures = _pendingFutureTargets[target];
+      for (int i = 0; i < pendingFutures.length;) {
+        if (pendingFutures[i].evaluate(cacheEntry)) {
+          pendingFutures.removeAt(i);
+        } else {
+          i++;
+        }
+      }
+    }
+  }
+
   @override
   void recordLibraryElements(Map<Source, LibraryElement> elementMap) {
     elementMap.forEach((Source librarySource, LibraryElement library) {
       //
       // Cache the element in the library's info.
       //
       CacheEntry entry = getCacheEntry(librarySource);
       setValue(ResultDescriptor result, value) {
         entry.setValue(result, value, TargetedResult.EMPTY_LIST);
       }
@@ skipping 845 matching lines @@
       throw new IllegalArgumentException(
           "The source factory for an SDK analysis context must have a DartUriResolver");
     }
     return new AnalysisCache(<CachePartition>[
       AnalysisEngine.instance.partitionManager_new.forSdk(sdk)
     ]);
   }
 }
 
 /**
- * A helper class used to create futures for AnalysisContextImpl. Using a helper
- * class allows us to preserve the generic parameter T.
+ * 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.
+   * [computeValue]. If [computeValue] returns non-`null`, the future will be
+   * completed immediately with the resulting value. If it returns `null`, then
+   * [scheduleComputation] is invoked to schedule analysis that will produce
+   * the required result, and [computeValue] 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(CacheEntry entry)) {
+  CancelableFuture<T> computeAsync(AnalysisTarget target,
+      T computeValue(CacheEntry entry), void scheduleComputation()) {
     if (_context.isDisposed) {
       // No further analysis is expected, so return a future that completes
       // immediately with AnalysisNotScheduledError.
       return new CancelableFuture.error(new AnalysisNotScheduledError());
     }
-    CacheEntry entry = _context.getReadableSourceEntryOrNull(target);
-    if (entry == null) {
-      return new CancelableFuture.error(new AnalysisNotScheduledError());
-    }
+    CacheEntry entry = _context.getCacheEntry(target);
     PendingFuture pendingFuture =
         new PendingFuture<T>(_context, target, computeValue);
     if (!pendingFuture.evaluate(entry)) {
       _context._pendingFutureTargets
           .putIfAbsent(target, () => <PendingFuture>[])
           .add(pendingFuture);
+      scheduleComputation();
     }
     return pendingFuture.future;
   }
 }