When a target is removed, invalidate all dependent results.

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 1614 matching lines @@
 //        oldPartMap[target] = dartEntry.getValue(DartEntry.INCLUDED_PARTS);
 //        dartEntry.invalidateAllResolutionInformation(invalidateUris);
 //        iterator.value = dartEntry;
 //        _workManager.add(target, _computePriority(dartEntry));
 //      }
 //    }
     _removeFromPartsUsingMap(oldPartMap);
   }
 
   /**
-   * In response to a change to at least one of the compilation units in the
-   * library defined by the given [librarySource], invalidate any results that
-   * are dependent on the result of resolving that library.
-   *
-   * <b>Note:</b> Any cache entries that were accessed before this method was
-   * invoked must be re-accessed after this method returns.
-   */
-  void _invalidateLibraryResolution(Source librarySource) {
-    // TODO(brianwilkerson) Figure out whether we still need this.
-    // TODO(brianwilkerson) This could be optimized. There's no need to flush
-    // all of these entries if the public namespace hasn't changed, which will
-    // be a fairly common case. The question is whether we can afford the time
-    // to compute the namespace to look for differences.
-//    DartEntry libraryEntry = _getReadableDartEntry(librarySource);
-//    if (libraryEntry != null) {
-//      List<Source> includedParts =
-//          libraryEntry.getValue(DartEntry.INCLUDED_PARTS);
-//      libraryEntry.invalidateAllResolutionInformation(false);
-//      _workManager.add(librarySource, SourcePriority.LIBRARY);
-//      for (Source partSource in includedParts) {
-//        SourceEntry partEntry = _cache.get(partSource);
-//        if (partEntry is DartEntry) {
-//          partEntry.invalidateAllResolutionInformation(false);
-//        }
-//      }
-//    }
-  }
-
-  /**
    * Log the given debugging [message].
    */
   void _logInformation(String message) {
     AnalysisEngine.instance.logger.logInformation(message);
   }
 
   /**
    * Notify all of the analysis listeners that the errors associated with the
    * given [source] has been updated to the given [errors].
    */
@@ skipping 131 matching lines @@
 //          new AnalysisException("This source was marked as being deleted"),
 //          null));
 //    }
     _removeFromPriorityOrder(source);
   }
 
   /**
    * Record that the given [source] has been removed.
    */
   void _sourceRemoved(Source source) {
-    List<Source> containingLibraries = getLibrariesContaining(source);
-    if (containingLibraries != null && containingLibraries.isNotEmpty) {
-      HashSet<Source> libraries = new HashSet<Source>();
-      for (Source librarySource in containingLibraries) {
-        libraries.add(librarySource);
-        for (Source dependentLibrary
-            in getLibrariesDependingOn(librarySource)) {
-          libraries.add(dependentLibrary);
-        }
-      }
-      for (Source librarySource in libraries) {
-        _invalidateLibraryResolution(librarySource);
-      }
-    }
     _cache.remove(source);
     _removeFromPriorityOrder(source);
   }
 
   /**
    * TODO(scheglov) A hackish, limited incremental resolution implementation.
    */
   bool _tryPoorMansIncrementalResolution(Source unitSource, String newCode) {
     // TODO(brianwilkerson) Implement this.
     return false;
@@ skipping 275 matching lines @@
     PendingFuture pendingFuture =
         new PendingFuture<T>(_context, target, computeValue);
     if (!pendingFuture.evaluate(entry)) {
       _context._pendingFutureTargets
           .putIfAbsent(target, () => <PendingFuture>[])
           .add(pendingFuture);
     }
     return pendingFuture.future;
   }
 }