New analyzer snapshot.

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 'java_core.dart';
@@ skipping 1721 matching lines @@
         } else if (identical(descriptor, DartEntry.HINTS)) {
           return identical(state._hintsState, CacheState.INVALID);
         }
       }
       return false;
     } else {
       return identical(super.getState(descriptor), CacheState.INVALID);
     }
   }
 
-  /**
-   * Invalidate all of the information associated with the compilation unit.
-   */
   void invalidateAllInformation() {
-    setState(SourceEntry.LINE_INFO, CacheState.INVALID);
+    super.invalidateAllInformation();
     _sourceKind = SourceKind.UNKNOWN;
     _sourceKindState = CacheState.INVALID;
     _parseErrors = AnalysisError.NO_ERRORS;
     _parseErrorsState = CacheState.INVALID;
     _parsedUnit = null;
     _parsedUnitAccessed = false;
     _parsedUnitState = CacheState.INVALID;
     discardCachedResolutionInformation();
   }
 
@@ skipping 815 matching lines @@
     }
     return super.getValue(descriptor);
   }
 
   HtmlEntryImpl get writableCopy {
     HtmlEntryImpl copy = new HtmlEntryImpl();
     copy.copyFrom(this);
     return copy;
   }
 
-  /**
-   * Invalidate all of the information associated with the HTML file.
-   */
   void invalidateAllInformation() {
-    setState(SourceEntry.LINE_INFO, CacheState.INVALID);
+    super.invalidateAllInformation();
     _parseErrors = AnalysisError.NO_ERRORS;
     _parseErrorsState = CacheState.INVALID;
     _parsedUnit = null;
     _parsedUnitState = CacheState.INVALID;
     _referencedLibraries = Source.EMPTY_ARRAY;
     _referencedLibrariesState = CacheState.INVALID;
     invalidateAllResolutionInformation();
   }
 
   /**
@@ skipping 245 matching lines @@
 
   Object getValue(DataDescriptor descriptor) {
     if (identical(descriptor, SourceEntry.LINE_INFO)) {
       return _lineInfo;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
 
   /**
+   * Invalidate all of the information associated with this source.
+   */
+  void invalidateAllInformation() {
+    _lineInfo = null;
+    _lineInfoState = CacheState.INVALID;
+  }
+
+  /**
    * Set the most recent time at which the state of the source matched the state represented by this
    * entry to the given time.
    *
    * @param time the new modification time of this entry
    */
   void set modificationTime(int time) {
     _modificationTime = time;
   }
 
   /**
@@ skipping 200 matching lines @@
    */
   List<Source> _priorityOrder = Source.EMPTY_ARRAY;
 
   /**
    * A table mapping sources to the change notices that are waiting to be returned related to that
    * source.
    */
   Map<Source, ChangeNoticeImpl> _pendingNotices = new Map<Source, ChangeNoticeImpl>();
 
   /**
+   * A set containing information about the tasks that have been performed since the last change
+   * notification. Used to detect infinite loops in [performAnalysisTask].
+   */
+  Set<String> _recentTasks = new Set<String>();
+
+  /**
    * The object used to synchronize access to all of the caches. The rules related to the use of
    * this lock object are
    *
    * * no analysis work is done while holding the lock, and
    * * no analysis results can be recorded unless we have obtained the lock and validated that the
    * results are for the same version (modification time) of the source as our current cache
    * content.
    *
    */
   Object _cacheLock = new Object();
@@ skipping 21 matching lines @@
     // This implementation assumes that the access to the cache does not need to be synchronized
     // because no other object can have access to this context while this method is being invoked.
     _cache.put(source, info);
   }
 
   void applyChanges(ChangeSet changeSet) {
     if (changeSet.isEmpty) {
       return;
     }
     {
+      _recentTasks.clear();
       //
       // First, compute the list of sources that have been removed.
       //
       List<Source> removedSources = new List<Source>.from(changeSet.removed3);
       for (SourceContainer container in changeSet.removedContainers) {
         addSourcesInContainer(removedSources, container);
       }
       //
       // Then determine which cached results are no longer valid.
       //
       bool addedDartSource = false;
       for (Source source in changeSet.added3) {
         if (sourceAvailable(source)) {
           addedDartSource = true;
         }
       }
       for (Source source in changeSet.changed3) {
         sourceChanged(source);
       }
       for (Source source in removedSources) {
         sourceRemoved(source);
       }
       if (addedDartSource) {
         // TODO(brianwilkerson) This is hugely inefficient, but we need to re-analyze any libraries
         // that might have been referencing the not-yet-existing source that was just added. Longer
         // term we need to keep track of which libraries are referencing non-existing sources and
         // only re-analyze those libraries.
+        logInformation("Added Dart sources, invalidating all resolution information");
         for (MapEntry<Source, SourceEntry> mapEntry in _cache.entrySet()) {
           SourceEntry sourceEntry = mapEntry.getValue();
           if (!mapEntry.getKey().isInSystemLibrary && sourceEntry is DartEntry) {
             DartEntryImpl dartCopy = sourceEntry.writableCopy;
             dartCopy.invalidateAllResolutionInformation();
             mapEntry.setValue(dartCopy);
           }
         }
       }
     }
@@ skipping 557 matching lines @@
   }
 
   CompilationUnit parseCompilationUnit(Source source) => getDartParseData2(source, DartEntry.PARSED_UNIT, null);
 
   HtmlUnit parseHtmlUnit(Source source) => getHtmlParseData(source, HtmlEntry.PARSED_UNIT, null);
 
   AnalysisResult performAnalysisTask() {
     int getStart = JavaSystem.currentTimeMillis();
     AnalysisTask task = nextTaskAnalysisTask;
     int getEnd = JavaSystem.currentTimeMillis();
+    if (task == null && validateCacheConsistency()) {
+      task = nextTaskAnalysisTask;
+    }
     if (task == null) {
       return new AnalysisResult(getChangeNotices(true), getEnd - getStart, null, -1);
     }
-    //System.out.println(task);
+    String taskDescriptor = task.toString();
+    if (_recentTasks.add(taskDescriptor)) {
+      logInformation("Performing task: ${taskDescriptor}");
+    } else {
+      logInformation("*** Performing repeated task: ${taskDescriptor}");
+    }
     int performStart = JavaSystem.currentTimeMillis();
     try {
       task.perform(_resultRecorder);
     } on AnalysisException catch (exception) {
       if (exception.cause is! JavaIOException) {
         AnalysisEngine.instance.logger.logError2("Internal error while performing the task: ${task}", exception);
       }
     }
     int performEnd = JavaSystem.currentTimeMillis();
     return new AnalysisResult(getChangeNotices(false), getEnd - getStart, task.runtimeType.toString(), performEnd - performStart);
@@ skipping 81 matching lines @@
         _priorityOrder = new List<Source>(count);
         for (int i = 0; i < count; i++) {
           _priorityOrder[i] = sources[i];
         }
       }
     }
   }
 
   void setChangedContents(Source source, String contents, int offset, int oldLength, int newLength) {
     {
+      _recentTasks.clear();
       String originalContents = _sourceFactory.setContents(source, contents);
       if (contents != null) {
         if (contents != originalContents) {
           if (_options.incremental) {
             _incrementalAnalysisCache = IncrementalAnalysisCache.update(_incrementalAnalysisCache, source, originalContents, contents, offset, oldLength, newLength, getReadableSourceEntry(source));
           }
           sourceChanged(source);
         }
       } else if (originalContents != null) {
         _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
         sourceChanged(source);
       }
     }
   }
 
   void setContents(Source source, String contents) {
     {
+      _recentTasks.clear();
       String originalContents = _sourceFactory.setContents(source, contents);
       if (contents != null) {
         if (contents != originalContents) {
           _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
           sourceChanged(source);
         }
       } else if (originalContents != null) {
         _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
         sourceChanged(source);
       }
@@ skipping 98 matching lines @@
               _cache.put(source, dartCopy);
               if (source == unitSource) {
                 unitEntry = dartCopy;
               }
               ChangeNoticeImpl notice = getNotice(source);
               notice.compilationUnit = unit;
               notice.setErrors(dartCopy.allErrors, lineInfo);
             }
           }
         } else {
+          PrintStringWriter writer = new PrintStringWriter();
+          writer.println("Library resolution results discarded for");
           for (Library library in resolvedLibraries) {
             for (Source source in library.compilationUnitSources) {
               DartEntry dartEntry = getReadableDartEntry(source);
               if (dartEntry != null) {
                 int resultTime = library.getModificationTime(source);
+                writer.println("  ${debuggingString(source)}; sourceTime = ${source.modificationStamp}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}");
                 DartEntryImpl dartCopy = dartEntry.writableCopy;
                 if (thrownException == null || resultTime >= 0) {
                   //
                   // The analysis was performed on out-of-date sources. Mark the cache so that the
                   // sources will be re-analyzed using the up-to-date sources.
                   //
                   dartCopy.recordResolutionNotInProcess();
                 } else {
                   //
                   // We could not determine whether the sources were up-to-date or out-of-date. Mark
                   // the cache so that we won't attempt to re-analyze the sources until there's a
                   // good chance that we'll be able to do so without error.
                   //
                   dartCopy.recordResolutionError();
                 }
                 dartCopy.exception = thrownException;
                 _cache.put(source, dartCopy);
                 if (source == unitSource) {
                   unitEntry = dartCopy;
                 }
+              } else {
+                writer.println("  ${debuggingString(source)}; sourceTime = ${source.modificationStamp}, no entry");
               }
             }
           }
+          logInformation(writer.toString());
         }
       }
     }
     if (thrownException != null) {
       throw thrownException;
     }
     if (unitEntry == null) {
       unitEntry = getReadableDartEntry(unitSource);
       if (unitEntry == null) {
         throw new AnalysisException.con1("A Dart file became a non-Dart file: ${unitSource.fullName}");
@@ skipping 287 matching lines @@
       return htmlEntry;
     } else {
       DartEntryImpl dartEntry = new DartEntryImpl();
       dartEntry.modificationTime = source.modificationStamp;
       _cache.put(source, dartEntry);
       return dartEntry;
     }
   }
 
   /**
+   * Return a string with debugging information about the given source (the full name and
+   * modification stamp of the source).
+   *
+   * @param source the source for which a debugging string is to be produced
+   * @return debugging information about the given source
+   */
+  String debuggingString(Source source) => "'${source.fullName}' [${source.modificationStamp}]";
+
+  /**
    * Return an array containing all of the change notices that are waiting to be returned. If there
    * are no notices, then return either `null` or an empty array, depending on the value of
    * the argument.
    *
    * @param nullIfEmpty `true` if `null` should be returned when there are no notices
    * @return the change notices that are waiting to be returned
    */
   List<ChangeNotice> getChangeNotices(bool nullIfEmpty) {
     {
       if (_pendingNotices.isEmpty) {
@@ skipping 536 matching lines @@
     }
   }
 
   /**
    * In response to a change to at least one of the compilation units in the given library,
    * invalidate any results that are dependent on the result of resolving that library.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param librarySource the source of the library being invalidated
+   * @param writer the writer to which debugging information should be written
    */
-  void invalidateLibraryResolution(Source librarySource) {
+  void invalidateLibraryResolution(Source librarySource, PrintStringWriter writer) {
     // TODO(brianwilkerson) This could be optimized. There's no need to flush all of these caches 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);
       DartEntryImpl libraryCopy = libraryEntry.writableCopy;
+      int oldTime = libraryCopy.modificationTime;
       libraryCopy.invalidateAllResolutionInformation();
       libraryCopy.setState(DartEntry.INCLUDED_PARTS, CacheState.INVALID);
       _cache.put(librarySource, libraryCopy);
+      if (writer != null) {
+        writer.println("  Invalidated library source: ${debuggingString(librarySource)} (previously modified at ${oldTime})");
+      }
       for (Source partSource in includedParts) {
         SourceEntry partEntry = _cache.get(partSource);
         if (partEntry is DartEntry) {
           DartEntryImpl partCopy = partEntry.writableCopy;
+          oldTime = partCopy.modificationTime;
           partCopy.invalidateAllResolutionInformation();
           _cache.put(partSource, partCopy);
+          if (writer != null) {
+            writer.println("  Invalidated part source: ${debuggingString(partSource)} (previously modified at ${oldTime})");
+          }
         }
       }
     }
   }
 
   /**
    * Return `true` if this library is, or depends on, dart:html.
    *
    * @param library the library being tested
    * @param visitedLibraries a collection of the libraries that have been visited, used to prevent
@@ skipping 15 matching lines @@
     }
     for (LibraryElement exported in library.exportedLibraries) {
       if (isClient(exported, htmlSource, visitedLibraries)) {
         return true;
       }
     }
     return false;
   }
 
   /**
+   * Log the given debugging information.
+   *
+   * @param message the message to be added to the log
+   */
+  void logInformation(String message) {
+    AnalysisEngine.instance.logger.logInformation(message);
+  }
+
+  /**
+   * Log the given debugging information.
+   *
+   * @param message the message to be added to the log
+   * @param exception the exception to be included in the log entry
+   */
+  void logInformation2(String message, Exception exception) {
+    if (exception == null) {
+      AnalysisEngine.instance.logger.logInformation(message);
+    } else {
+      AnalysisEngine.instance.logger.logInformation3(message, exception);
+    }
+  }
+
+  /**
    * Given a cache entry and a library element, record the library element and other information
    * gleaned from the element in the cache entry.
    *
    * @param dartCopy the cache entry in which data is to be recorded
    * @param library the library element used to record information
    * @param htmlSource the source for the HTML library
    */
   void recordElementData(DartEntryImpl dartCopy, LibraryElement library, Source htmlSource) {
     dartCopy.setValue(DartEntry.ELEMENT, library);
     dartCopy.setValue(DartEntry.IS_LAUNCHABLE, library.entryPoint != null);
@@ skipping 45 matching lines @@
           dartCopy.setValue2(DartEntry.VERIFICATION_ERRORS, librarySource, task.errors);
           ChangeNoticeImpl notice = getNotice(source);
           notice.setErrors(dartCopy.allErrors, dartCopy.getValue(SourceEntry.LINE_INFO));
         } else {
           dartCopy.setState2(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.ERROR);
         }
         dartCopy.exception = thrownException;
         _cache.put(source, dartCopy);
         dartEntry = dartCopy;
       } else {
+        logInformation2("Generated errors discarded for ${debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         if (thrownException == null || resultTime >= 0) {
           //
           // The analysis was performed on out-of-date sources. Mark the cache so that the source
           // will be re-verified using the up-to-date sources.
           //
           dartCopy.setState2(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.INVALID);
         } else {
           //
           // We could not determine whether the sources were up-to-date or out-of-date. Mark the
@@ skipping 77 matching lines @@
             dartCopy.setValue2(DartEntry.HINTS, librarySource, results.data);
             ChangeNoticeImpl notice = getNotice(unitSource);
             notice.setErrors(dartCopy.allErrors, dartCopy.getValue(SourceEntry.LINE_INFO));
           } else {
             dartCopy.setState2(DartEntry.HINTS, librarySource, CacheState.ERROR);
           }
           dartCopy.exception = thrownException;
           _cache.put(unitSource, dartCopy);
           dartEntry = dartCopy;
         } else {
+          logInformation2("Generated hints discarded for ${debuggingString(unitSource)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
           if (identical(dartEntry.getState2(DartEntry.HINTS, librarySource), CacheState.IN_PROCESS)) {
             DartEntryImpl dartCopy = dartEntry.writableCopy;
             if (thrownException == null || resultTime >= 0) {
               //
               // The analysis was performed on out-of-date sources. Mark the cache so that the sources
               // will be re-analyzed using the up-to-date sources.
               //
               dartCopy.setState2(DartEntry.HINTS, librarySource, CacheState.INVALID);
             } else {
               //
@@ skipping 86 matching lines @@
           // Verify that the incrementally parsed and resolved unit in the incremental cache
           // is structurally equivalent to the fully parsed unit
           _incrementalAnalysisCache = IncrementalAnalysisCache.verifyStructure(_incrementalAnalysisCache, source, task.compilationUnit);
         } else {
           dartCopy.recordParseError();
         }
         dartCopy.exception = thrownException;
         _cache.put(source, dartCopy);
         dartEntry = dartCopy;
       } else {
+        logInformation2("Parse results discarded for ${debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         if (thrownException == null || resultTime >= 0) {
           //
           // The analysis was performed on out-of-date sources. Mark the cache so that the sources
           // will be re-analyzed using the up-to-date sources.
           //
           dartCopy.recordParseNotInProcess();
         } else {
           //
           // We could not determine whether the sources were up-to-date or out-of-date. Mark the
@@ skipping 55 matching lines @@
           htmlCopy.setValue(HtmlEntry.REFERENCED_LIBRARIES, task.referencedLibraries);
           ChangeNoticeImpl notice = getNotice(source);
           notice.setErrors(htmlEntry.allErrors, lineInfo);
         } else {
           htmlCopy.recordParseError();
         }
         htmlCopy.exception = thrownException;
         _cache.put(source, htmlCopy);
         htmlEntry = htmlCopy;
       } else {
+        logInformation2("Parse results discarded for ${debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${htmlEntry.modificationTime}", thrownException);
         HtmlEntryImpl htmlCopy = (sourceEntry as HtmlEntry).writableCopy;
         if (thrownException == null || resultTime >= 0) {
           //
           // The analysis was performed on out-of-date sources. Mark the cache so that the sources
           // will be re-analyzed using the up-to-date sources.
           //
           if (identical(htmlCopy.getState(SourceEntry.LINE_INFO), CacheState.IN_PROCESS)) {
             htmlCopy.setState(SourceEntry.LINE_INFO, CacheState.INVALID);
           }
           if (identical(htmlCopy.getState(HtmlEntry.PARSED_UNIT), CacheState.IN_PROCESS)) {
@@ skipping 59 matching lines @@
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         if (thrownException == null) {
           dartCopy.setValue2(DartEntry.RESOLVED_UNIT, librarySource, task.resolvedUnit);
         } else {
           dartCopy.setState2(DartEntry.RESOLVED_UNIT, librarySource, CacheState.ERROR);
         }
         dartCopy.exception = thrownException;
         _cache.put(unitSource, dartCopy);
         dartEntry = dartCopy;
       } else {
+        logInformation2("Resolution results discarded for ${debuggingString(unitSource)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         if (thrownException == null || resultTime >= 0) {
           //
           // The analysis was performed on out-of-date sources. Mark the cache so that the sources
           // will be re-analyzed using the up-to-date sources.
           //
           if (identical(dartCopy.getState(DartEntry.RESOLVED_UNIT), CacheState.IN_PROCESS)) {
             dartCopy.setState2(DartEntry.RESOLVED_UNIT, librarySource, CacheState.INVALID);
           }
         } else {
@@ skipping 54 matching lines @@
           ChangeNoticeImpl notice = getNotice(source);
           notice.htmlUnit = task.resolvedUnit;
           notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
         } else {
           htmlCopy.recordResolutionError();
         }
         htmlCopy.exception = thrownException;
         _cache.put(source, htmlCopy);
         htmlEntry = htmlCopy;
       } else {
+        logInformation2("Resolution results discarded for ${debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${htmlEntry.modificationTime}", thrownException);
         HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
         if (thrownException == null || resultTime >= 0) {
           //
           // The analysis was performed on out-of-date sources. Mark the cache so that the sources
           // will be re-analyzed using the up-to-date sources.
           //
           if (identical(htmlCopy.getState(HtmlEntry.ELEMENT), CacheState.IN_PROCESS)) {
             htmlCopy.setState(HtmlEntry.ELEMENT, CacheState.INVALID);
           }
           if (identical(htmlCopy.getState(HtmlEntry.RESOLUTION_ERRORS), CacheState.IN_PROCESS)) {
@@ skipping 24 matching lines @@
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source that has been added
    * @return `true` if the new source is a Dart file
    */
   bool sourceAvailable(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       sourceEntry = createSourceEntry(source);
+      logInformation("Added new source: ${debuggingString(source)}");
     } else {
       SourceEntryImpl sourceCopy = sourceEntry.writableCopy;
+      int oldTime = sourceCopy.modificationTime;
       sourceCopy.modificationTime = source.modificationStamp;
+      // TODO(brianwilkerson) Understand why we're not invalidating the cache.
       _cache.put(source, sourceCopy);
+      logInformation("Added new source: ${debuggingString(source)} (previously modified at ${oldTime})");
     }
     return sourceEntry is DartEntry;
   }
 
   /**
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source that has been changed
    */
   void sourceChanged(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null || sourceEntry.modificationTime == source.modificationStamp) {
       // Either we have removed this source, in which case we don't care that it is changed, or we
       // have already invalidated the cache and don't need to invalidate it again.
+      if (sourceEntry == null) {
+        logInformation("Modified source, but there is no entry: ${debuggingString(source)}");
+      } else {
+        logInformation("Modified source, but modification time matches: ${debuggingString(source)}");
+      }
       return;
     }
     if (sourceEntry is HtmlEntry) {
       HtmlEntryImpl htmlCopy = sourceEntry.writableCopy;
+      int oldTime = htmlCopy.modificationTime;
       htmlCopy.modificationTime = source.modificationStamp;
       htmlCopy.invalidateAllInformation();
       _cache.put(source, htmlCopy);
+      logInformation("Modified HTML source: ${debuggingString(source)} (previously modified at ${oldTime})");
     } else if (sourceEntry is DartEntry) {
       List<Source> containingLibraries = getLibrariesContaining(source);
       Set<Source> librariesToInvalidate = new Set<Source>();
       for (Source containingLibrary in containingLibraries) {
         librariesToInvalidate.add(containingLibrary);
         for (Source dependentLibrary in getLibrariesDependingOn(containingLibrary)) {
           librariesToInvalidate.add(dependentLibrary);
         }
       }
+      PrintStringWriter writer = new PrintStringWriter();
+      int oldTime = sourceEntry.modificationTime;
+      writer.println("Modified Dart source: ${debuggingString(source)} (previously modified at ${oldTime})");
       for (Source library in librariesToInvalidate) {
         //    for (Source library : containingLibraries) {
-        invalidateLibraryResolution(library);
+        invalidateLibraryResolution(library, writer);
       }
       DartEntryImpl dartCopy = sourceEntry.writableCopy;
       dartCopy.modificationTime = source.modificationStamp;
       dartCopy.invalidateAllInformation();
       _cache.put(source, dartCopy);
+      logInformation(writer.toString());
     }
   }
 
   /**
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source that has been deleted
    */
   void sourceRemoved(Source source) {
+    PrintStringWriter writer = new PrintStringWriter();
+    writer.println("Removed source: ${debuggingString(source)}");
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry is DartEntry) {
       Set<Source> libraries = new Set<Source>();
       for (Source librarySource in getLibrariesContaining(source)) {
         libraries.add(librarySource);
         for (Source dependentLibrary in getLibrariesDependingOn(librarySource)) {
           libraries.add(dependentLibrary);
         }
       }
       for (Source librarySource in libraries) {
-        invalidateLibraryResolution(librarySource);
+        invalidateLibraryResolution(librarySource, writer);
       }
     }
     _cache.remove(source);
+    logInformation(writer.toString());
+  }
+
+  /**
+   * Check the cache for any invalid entries (entries whose modification time does not match the
+   * modification time of the source associated with the entry). Invalid entries will be marked as
+   * invalid so that the source will be re-analyzed.
+   *
+   * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
+   *
+   * @return `true` if at least one entry was invalid
+   */
+  bool validateCacheConsistency() {
+    int consistencyCheckStart = JavaSystem.nanoTime();
+    int inconsistentCount = 0;
+    {
+      for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
+        Source source = entry.getKey();
+        SourceEntry sourceEntry = entry.getValue();
+        int sourceTime = source.modificationStamp;
+        if (sourceTime != sourceEntry.modificationTime) {
+          sourceChanged(source);
+          inconsistentCount++;
+        }
+      }
+    }
+    int consistencyCheckEnd = JavaSystem.nanoTime();
+    logInformation("Consistency check found ${inconsistentCount} inconsistent entries in ${((consistencyCheckEnd - consistencyCheckStart) / 1000000.0)} ms");
+    return inconsistentCount > 0;
   }
 }
 
 /**
  * Instances of the class `AnalysisTaskResultRecorder` are used by an analysis context to
  * record the results of a task.
  */
 class AnalysisContextImpl_AnalysisTaskResultRecorder implements AnalysisTaskVisitor<SourceEntry> {
   final AnalysisContextImpl AnalysisContextImpl_this;
 
@@ skipping 1662 matching lines @@
    *
    * @param visitor the visitor used to visit this task after it has completed
    * @return the value returned by the visitor
    * @throws AnalysisException if the visitor throws the exception
    */
   Object perform(AnalysisTaskVisitor visitor) {
     try {
       safelyPerform();
     } on AnalysisException catch (exception) {
       _thrownException = exception;
-      AnalysisEngine.instance.logger.logInformation2("Task failed: ${taskDescription}", exception);
+      AnalysisEngine.instance.logger.logInformation3("Task failed: ${taskDescription}", exception);
     }
     return accept(visitor);
   }
 
   String toString() => taskDescription;
 
   /**
    * Return a textual description of this task.
    *
    * @return a textual description of this task
@@ skipping 1124 matching lines @@
    * @param exception the exception being logged
    */
   void logInformation(String message);
 
   /**
    * Log the given exception as one representing an informational message.
    *
    * @param message an explanation of why the error occurred or what it means
    * @param exception the exception being logged
    */
-  void logInformation2(String message, Exception exception);
+  void logInformation3(String message, Exception exception);
 }
 
 /**
  * Implementation of [Logger] that does nothing.
  */
 class Logger_NullLogger implements Logger {
   void logError(String message) {
   }
 
   void logError2(String message, Exception exception) {
   }
 
   void logError3(Exception exception) {
   }
 
   void logInformation(String message) {
   }
 
-  void logInformation2(String message, Exception exception) {
+  void logInformation3(String message, Exception exception) {
   }
 }