Don't remove indexing operations on potential source changes.

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;
@@ skipping 1835 matching lines @@
     _disposed = true;
     for (List<PendingFuture> pendingFutures in _pendingFutureSources.values) {
       for (PendingFuture pendingFuture in pendingFutures) {
         pendingFuture.forciblyComplete();
       }
     }
     _pendingFutureSources.clear();
   }
 
   @override
-  CompilationUnit ensureAnyResolvedDartUnit(Source source) {
-    SourceEntry sourceEntry = _cache.get(source);
+  List<CompilationUnit> ensureResolvedDartUnits(Source unitSource) {

[Brian Wilkerson, 2015/02/27 21:56:21]

I might be misreading this code, but...

It looks like we are requiring that the unit be resolved in all of its libraries
simultaneously. If the act of resolving the unit in one library causes the AST
for a different library to be flushed from the cache, this could lead to an
infinite loop. It won't be a common case, but we should guard against it.

[scheglov, 2015/02/28 01:34:35]

We don't rerun this method.
We ask it only only - if all the resolved units are present.
If yes, we use them.
If not, we rely on the normal perform tasks cycle to provide us this these
resolved units later.

+    SourceEntry sourceEntry = _cache.get(unitSource);
     if (sourceEntry is! DartEntry) {
       return null;
     }
     DartEntry dartEntry = sourceEntry;
-    // Check if there is a resolved unit.
-    CompilationUnit unit = dartEntry.anyResolvedCompilationUnit;
-    if (unit != null) {
-      return unit;
+    // Check every library.
+    List<CompilationUnit> units = <CompilationUnit>[];
+    List<Source> containingLibraries = dartEntry.containingLibraries;
+    for (Source librarySource in containingLibraries) {
+      CompilationUnit unit =
+          dartEntry.getValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource);
+      if (unit == null) {
+        units = null;
+        break;
+      }
+      units.add(unit);
     }
     // Invalidate the flushed RESOLVED_UNIT to force it eventually.
-    bool shouldBeScheduled = false;
-    List<Source> librariesContaining = dartEntry.containingLibraries;
-    for (Source librarySource in librariesContaining) {
-      if (dartEntry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource) ==
-          CacheState.FLUSHED) {
-        dartEntry.setStateInLibrary(
+    if (units == null) {
+      bool shouldBeScheduled = false;
+      for (Source librarySource in containingLibraries) {
+        if (dartEntry.getStateInLibrary(
             DartEntry.RESOLVED_UNIT,
-            librarySource,
-            CacheState.INVALID);
-        shouldBeScheduled = true;
+            librarySource) ==
+            CacheState.FLUSHED) {
+          dartEntry.setStateInLibrary(
+              DartEntry.RESOLVED_UNIT,
+              librarySource,
+              CacheState.INVALID);
+          shouldBeScheduled = true;
+        }
       }
+      if (shouldBeScheduled) {
+        _workManager.add(unitSource, SourcePriority.UNKNOWN);
+      }
+      // We cannot provide a resolved unit right now,

[Paul Berry, 2015/02/27 22:05:00]

s/a resolved unit/resolved units/

[scheglov, 2015/02/28 01:34:35]

Done.

+      // but the future analysis will.
+      return null;
     }
-    if (shouldBeScheduled) {
-      _workManager.add(source, SourcePriority.UNKNOWN);
-    }
-    // We cannot provide a resolved unit right now,
-    // but the future analysis will.
-    return null;
+    // done
+    return units;
   }
 
   @override
   bool exists(Source source) {
     if (source == null) {
       return false;
     }
     if (_contentCache.getContents(source) != null) {
       return true;
     }
@@ skipping 7905 matching lines @@
    *
    * <b>Note:</b> This method cannot be used in an async environment
    *
    * @param source the compilation unit for which an AST structure should be returned
    * @return the AST structure representing the content of the source
    * @throws AnalysisException if the analysis could not be performed
    */
   CompilationUnit computeResolvableCompilationUnit(Source source);
 
   /**
-   * Return any resolved [CompilationUnit] for the given [source] if not
-   * flushed, otherwise return `null` and ensures that the [CompilationUnit]
+   * Return all the resolved [CompilationUnit]s for the given [source] if not
+   * flushed, otherwise return `null` and ensures that the [CompilationUnit]s
    * will be eventually returned to the client from [performAnalysisTask].
    */
-  CompilationUnit ensureAnyResolvedDartUnit(Source source);
+  List<CompilationUnit> ensureResolvedDartUnits(Source source);
 
   /**
    * Return context that owns the given source.
    *
    * @param source the source whose context is to be returned
    * @return the context that owns the partition that contains the source
    */
   InternalAnalysisContext getContextFor(Source source);
 
   /**
@@ skipping 2661 matching lines @@
     if (element.id == _id) {
       result = element;
       throw new _ElementByIdFinderException();
     }
     super.visitElement(element);
   }
 }
 
 class _ElementByIdFinderException {
 }