New analyzer_experimental snapshot.

pkg/analyzer_experimental/lib/src/generated/engine.dart

 // 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';
 import 'java_engine.dart';
 import 'utilities_collection.dart';
 import 'utilities_general.dart';
 import 'instrumentation.dart';
 import 'error.dart';
 import 'source.dart';
@@ skipping 1140 matching lines @@
    * The data descriptor representing the resolved AST structure.
    */
   static final DataDescriptor<CompilationUnit> RESOLVED_UNIT = new DataDescriptor<CompilationUnit>("DartEntry.RESOLVED_UNIT");
 
   /**
    * The data descriptor representing the source kind.
    */
   static final DataDescriptor<SourceKind> SOURCE_KIND = new DataDescriptor<SourceKind>("DartEntry.SOURCE_KIND");
 
   /**
+   * The data descriptor representing the errors resulting from verifying the source.
+   */
+  static final DataDescriptor<List<AnalysisError>> VERIFICATION_ERRORS = new DataDescriptor<List<AnalysisError>>("DartEntry.VERIFICATION_ERRORS");
+
+  /**
    * Return all of the errors associated with the compilation unit that are currently cached.
    *
    * @return all of the errors associated with the compilation unit
    */
   List<AnalysisError> get allErrors;
 
   /**
    * Return a valid parsed compilation unit, either an unresolved AST structure or the result of
    * resolving the AST structure in the context of some library, or `null` if there is no
    * parsed compilation unit available.
@@ skipping 179 matching lines @@
   List<AnalysisError> get allErrors {
     List<AnalysisError> errors = new List<AnalysisError>();
     for (AnalysisError error in _parseErrors) {
       errors.add(error);
     }
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
       for (AnalysisError error in state._resolutionErrors) {
         errors.add(error);
       }
+      for (AnalysisError error in state._verificationErrors) {
+        errors.add(error);
+      }
       for (AnalysisError error in state._hints) {
         errors.add(error);
       }
       state = state._nextState;
     }
     ;
     if (errors.length == 0) {
       return AnalysisError.NO_ERRORS;
     }
     return new List.from(errors);
@@ skipping 71 matching lines @@
     }
   }
   CacheState getState2(DataDescriptor descriptor, Source librarySource) {
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
       if (librarySource == state._librarySource) {
         if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
           return state._resolutionErrorsState;
         } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
           return state._resolvedUnitState;
+        } else if (identical(descriptor, DartEntry.VERIFICATION_ERRORS)) {
+          return state._verificationErrorsState;
         } else if (identical(descriptor, DartEntry.HINTS)) {
           return state._hintsState;
         } else {
           throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
         }
       }
       state = state._nextState;
     }
     ;
-    if (identical(descriptor, DartEntry.RESOLUTION_ERRORS) || identical(descriptor, DartEntry.RESOLVED_UNIT) || identical(descriptor, DartEntry.HINTS)) {
+    if (identical(descriptor, DartEntry.RESOLUTION_ERRORS) || identical(descriptor, DartEntry.RESOLVED_UNIT) || identical(descriptor, DartEntry.VERIFICATION_ERRORS) || identical(descriptor, DartEntry.HINTS)) {
       return CacheState.INVALID;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
   Object getValue(DataDescriptor descriptor) {
     if (identical(descriptor, DartEntry.ELEMENT)) {
       return _element as Object;
     } else if (identical(descriptor, DartEntry.EXPORTED_LIBRARIES)) {
       return _exportedLibraries as Object;
@@ skipping 18 matching lines @@
     return super.getValue(descriptor);
   }
   Object getValue2(DataDescriptor descriptor, Source librarySource) {
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
       if (librarySource == state._librarySource) {
         if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
           return state._resolutionErrors as Object;
         } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
           return state._resolvedUnit as Object;
+        } else if (identical(descriptor, DartEntry.VERIFICATION_ERRORS)) {
+          return state._verificationErrors as Object;
         } else if (identical(descriptor, DartEntry.HINTS)) {
           return state._hints as Object;
         } else {
           throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
         }
       }
       state = state._nextState;
     }
     ;
-    if (identical(descriptor, DartEntry.RESOLUTION_ERRORS) || identical(descriptor, DartEntry.HINTS)) {
+    if (identical(descriptor, DartEntry.RESOLUTION_ERRORS) || identical(descriptor, DartEntry.VERIFICATION_ERRORS) || identical(descriptor, DartEntry.HINTS)) {
       return AnalysisError.NO_ERRORS as Object;
     } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
       return null;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
   DartEntryImpl get writableCopy {
     DartEntryImpl copy = new DartEntryImpl();
     copy.copyFrom(this);
@@ skipping 253 matching lines @@
    * @param cacheState the new state of the data represented by the given descriptor
    */
   void setState2(DataDescriptor descriptor, Source librarySource, CacheState cacheState) {
     DartEntryImpl_ResolutionState state = getOrCreateResolutionState(librarySource);
     if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
       state._resolutionErrors = updatedValue(cacheState, state._resolutionErrors, AnalysisError.NO_ERRORS);
       state._resolutionErrorsState = cacheState;
     } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
       state._resolvedUnit = updatedValue(cacheState, state._resolvedUnit, null);
       state._resolvedUnitState = cacheState;
+    } else if (identical(descriptor, DartEntry.VERIFICATION_ERRORS)) {
+      state._verificationErrors = updatedValue(cacheState, state._verificationErrors, AnalysisError.NO_ERRORS);
+      state._verificationErrorsState = cacheState;
     } else if (identical(descriptor, DartEntry.HINTS)) {
       state._hints = updatedValue(cacheState, state._hints, AnalysisError.NO_ERRORS);
       state._hintsState = cacheState;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
   void setValue(DataDescriptor descriptor, Object value) {
     if (identical(descriptor, DartEntry.ELEMENT)) {
       _element = value as LibraryElement;
@@ skipping 41 matching lines @@
    * @param value the new value of the data represented by the given descriptor and library
    */
   void setValue2(DataDescriptor descriptor, Source librarySource, Object value) {
     DartEntryImpl_ResolutionState state = getOrCreateResolutionState(librarySource);
     if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
       state._resolutionErrors = value == null ? AnalysisError.NO_ERRORS : (value as List<AnalysisError>);
       state._resolutionErrorsState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
       state._resolvedUnit = value as CompilationUnit;
       state._resolvedUnitState = CacheState.VALID;
+    } else if (identical(descriptor, DartEntry.VERIFICATION_ERRORS)) {
+      state._verificationErrors = value == null ? AnalysisError.NO_ERRORS : (value as List<AnalysisError>);
+      state._verificationErrorsState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.HINTS)) {
       state._hints = value == null ? AnalysisError.NO_ERRORS : (value as List<AnalysisError>);
       state._hintsState = CacheState.VALID;
     }
   }
   void copyFrom(SourceEntryImpl entry) {
     super.copyFrom(entry);
     DartEntryImpl other = entry as DartEntryImpl;
     _sourceKindState = other._sourceKindState;
     _sourceKind = other._sourceKind;
@@ skipping 121 matching lines @@
    */
   CacheState _resolutionErrorsState = CacheState.INVALID;
 
   /**
    * The errors produced while resolving the compilation unit, or an empty array if the errors are
    * not currently cached.
    */
   List<AnalysisError> _resolutionErrors = AnalysisError.NO_ERRORS;
 
   /**
+   * The state of the cached verification errors.
+   */
+  CacheState _verificationErrorsState = CacheState.INVALID;
+
+  /**
+   * The errors produced while verifying the compilation unit, or an empty array if the errors are
+   * not currently cached.
+   */
+  List<AnalysisError> _verificationErrors = AnalysisError.NO_ERRORS;
+
+  /**
    * The state of the cached hints.
    */
   CacheState _hintsState = CacheState.INVALID;
 
   /**
    * The hints produced while auditing the compilation unit, or an empty array if the hints are
    * not currently cached.
    */
   List<AnalysisError> _hints = AnalysisError.NO_ERRORS;
 
   /**
    * Set this state to be exactly like the given state, recursively copying the next state as
    * necessary.
    *
    * @param other the state to be copied
    */
   void copyFrom(DartEntryImpl_ResolutionState other) {
     _librarySource = other._librarySource;
     _resolvedUnitState = other._resolvedUnitState;
     _resolvedUnit = other._resolvedUnit;
     _resolutionErrorsState = other._resolutionErrorsState;
     _resolutionErrors = other._resolutionErrors;
+    _verificationErrorsState = other._verificationErrorsState;
+    _verificationErrors = other._verificationErrors;
     _hintsState = other._hintsState;
     _hints = other._hints;
     if (other._nextState != null) {
       _nextState = new DartEntryImpl_ResolutionState();
       _nextState.copyFrom(other._nextState);
     }
   }
 
   /**
    * Flush any AST structures being maintained by this state.
@@ skipping 11 matching lines @@
   /**
    * Invalidate all of the resolution information associated with the compilation unit.
    */
   void invalidateAllResolutionInformation() {
     _nextState = null;
     _librarySource = null;
     _resolvedUnitState = CacheState.INVALID;
     _resolvedUnit = null;
     _resolutionErrorsState = CacheState.INVALID;
     _resolutionErrors = AnalysisError.NO_ERRORS;
+    _verificationErrorsState = CacheState.INVALID;
+    _verificationErrors = AnalysisError.NO_ERRORS;
     _hintsState = CacheState.INVALID;
     _hints = AnalysisError.NO_ERRORS;
   }
 
   /**
    * Record that an error occurred while attempting to scan or parse the entry represented by this
    * entry. This will set the state of all resolution-based information as being in error, but
    * will not change the state of any parse results.
    */
   void recordResolutionError() {
     _nextState = null;
     _librarySource = null;
     _resolvedUnitState = CacheState.ERROR;
     _resolvedUnit = null;
     _resolutionErrorsState = CacheState.ERROR;
     _resolutionErrors = AnalysisError.NO_ERRORS;
+    _verificationErrorsState = CacheState.ERROR;
+    _verificationErrors = AnalysisError.NO_ERRORS;
     _hintsState = CacheState.ERROR;
     _hints = AnalysisError.NO_ERRORS;
   }
 
   /**
    * Record that an in-process parse has stopped without recording results because the results
    * were invalidated before they could be recorded.
    */
   void recordResolutionNotInProcess() {
     if (identical(_resolvedUnitState, CacheState.IN_PROCESS)) {
       _resolvedUnitState = CacheState.INVALID;
     }
     if (identical(_resolutionErrorsState, CacheState.IN_PROCESS)) {
       _resolutionErrorsState = CacheState.INVALID;
     }
+    if (identical(_verificationErrorsState, CacheState.IN_PROCESS)) {
+      _verificationErrorsState = CacheState.INVALID;
+    }
     if (identical(_hintsState, CacheState.IN_PROCESS)) {
       _hintsState = CacheState.INVALID;
     }
     if (_nextState != null) {
       _nextState.recordResolutionNotInProcess();
     }
   }
 
   /**
    * Write a textual representation of this state to the given builder. The result will only be
    * used for debugging purposes.
    *
    * @param builder the builder to which the text should be written
    */
   void writeOn(JavaStringBuilder builder) {
     if (_librarySource != null) {
       builder.append("; resolvedUnit = ");
       builder.append(_resolvedUnitState);
       builder.append("; resolutionErrors = ");
       builder.append(_resolutionErrorsState);
+      builder.append("; verificationErrors = ");
+      builder.append(_verificationErrorsState);
       builder.append("; hints = ");
       builder.append(_hintsState);
       if (_nextState != null) {
         _nextState.writeOn(builder);
       }
     }
   }
 }
 /**
  * Instances of the class `DataDescriptor` are immutable constants representing data that can
@@ skipping 683 matching lines @@
   List<AnalysisError> computeErrors(Source source) {
     bool enableHints = analysisOptions.hint;
     SourceEntry sourceEntry = getReadableSourceEntry(source);
     if (sourceEntry is DartEntry) {
       List<AnalysisError> errors = new List<AnalysisError>();
       DartEntry dartEntry = sourceEntry as DartEntry;
       ListUtilities.addAll(errors, getDartParseData(source, dartEntry, DartEntry.PARSE_ERRORS));
       dartEntry = getReadableDartEntry(source);
       if (identical(dartEntry.getValue(DartEntry.SOURCE_KIND), SourceKind.LIBRARY)) {
         ListUtilities.addAll(errors, getDartResolutionData(source, source, dartEntry, DartEntry.RESOLUTION_ERRORS));
+        ListUtilities.addAll(errors, getDartVerificationData(source, source, dartEntry, DartEntry.VERIFICATION_ERRORS));
         if (enableHints) {
           ListUtilities.addAll(errors, getDartHintData(source, source, dartEntry, DartEntry.HINTS));
         }
       } else {
         List<Source> libraries = getLibrariesContaining(source);
         for (Source librarySource in libraries) {
           ListUtilities.addAll(errors, getDartResolutionData(source, librarySource, dartEntry, DartEntry.RESOLUTION_ERRORS));
+          ListUtilities.addAll(errors, getDartVerificationData(source, librarySource, dartEntry, DartEntry.VERIFICATION_ERRORS));
           if (enableHints) {
             ListUtilities.addAll(errors, getDartHintData(source, librarySource, dartEntry, DartEntry.HINTS));
           }
         }
       }
       if (errors.isEmpty) {
         return AnalysisError.NO_ERRORS;
       }
       return new List.from(errors);
     } else if (sourceEntry is HtmlEntry) {
@@ skipping 301 matching lines @@
   /**
    * Return a list of the sources that would be processed by [performAnalysisTask]. This
    * method duplicates, and must therefore be kept in sync with, [getNextTaskAnalysisTask].
    * This method is intended to be used for testing purposes only.
    *
    * @return a list of the sources that would be processed by [performAnalysisTask]
    */
   List<Source> get sourcesNeedingProcessing {
     Set<Source> sources = new Set<Source>();
     {
+      bool hintsEnabled = analysisOptions.hint;
       for (Source source in _cache.priorityOrder) {
-        SourceEntry sourceEntry = _cache.get(source);
-        if (sourceEntry is DartEntry) {
-          DartEntry dartEntry = sourceEntry as DartEntry;
-          CacheState parseErrorsState = dartEntry.getState(DartEntry.PARSE_ERRORS);
-          if (identical(parseErrorsState, CacheState.INVALID) || identical(parseErrorsState, CacheState.FLUSHED)) {
-            javaSetAdd(sources, source);
-          }
-          CompilationUnit parseUnit = dartEntry.anyParsedCompilationUnit;
-          if (parseUnit == null) {
-            javaSetAdd(sources, source);
-          }
-          for (Source librarySource in getLibrariesContaining(source)) {
-            SourceEntry libraryEntry = _cache.get(librarySource);
-            if (libraryEntry is DartEntry) {
-              CacheState elementState = libraryEntry.getState(DartEntry.ELEMENT);
-              if (identical(elementState, CacheState.INVALID) || identical(elementState, CacheState.FLUSHED)) {
-                javaSetAdd(sources, source);
-              }
-              CacheState resolvedUnitState = dartEntry.getState2(DartEntry.RESOLVED_UNIT, librarySource);
-              if (identical(resolvedUnitState, CacheState.INVALID) || identical(resolvedUnitState, CacheState.FLUSHED)) {
-                LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
-                if (libraryElement != null) {
-                  javaSetAdd(sources, source);
-                }
-              }
-              CacheState hintsState = dartEntry.getState2(DartEntry.HINTS, librarySource);
-              if (identical(hintsState, CacheState.INVALID) || identical(hintsState, CacheState.FLUSHED)) {
-                LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
-                if (libraryElement != null) {
-                  javaSetAdd(sources, source);
-                }
-              }
-            }
-          }
-        } else if (sourceEntry is HtmlEntry) {
-          HtmlEntry htmlEntry = sourceEntry as HtmlEntry;
-          CacheState parsedUnitState = htmlEntry.getState(HtmlEntry.PARSED_UNIT);
-          if (identical(parsedUnitState, CacheState.INVALID) || identical(parsedUnitState, CacheState.FLUSHED)) {
-            javaSetAdd(sources, source);
-          }
-          CacheState elementState = htmlEntry.getState(HtmlEntry.ELEMENT);
-          if (identical(elementState, CacheState.INVALID) || identical(elementState, CacheState.FLUSHED)) {
-            javaSetAdd(sources, source);
-          }
-        }
+        getSourcesNeedingProcessing2(source, _cache.get(source), true, hintsEnabled, sources);
       }
       for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
-        SourceEntry sourceEntry = entry.getValue();
-        if (sourceEntry is DartEntry) {
-          DartEntry dartEntry = sourceEntry as DartEntry;
-          if (identical(dartEntry.getState(DartEntry.PARSED_UNIT), CacheState.INVALID)) {
-            javaSetAdd(sources, entry.getKey());
-          }
-        } else if (sourceEntry is HtmlEntry) {
-          HtmlEntry htmlEntry = sourceEntry as HtmlEntry;
-          if (identical(htmlEntry.getState(HtmlEntry.PARSED_UNIT), CacheState.INVALID)) {
-            javaSetAdd(sources, entry.getKey());
-          }
-        }
-      }
-      for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
-        SourceEntry sourceEntry = entry.getValue();
-        if (sourceEntry is DartEntry) {
-          DartEntry dartEntry = sourceEntry as DartEntry;
-          if (identical(dartEntry.kind, SourceKind.LIBRARY) && identical(dartEntry.getState(DartEntry.ELEMENT), CacheState.INVALID)) {
-            javaSetAdd(sources, entry.getKey());
-          } else if (identical(dartEntry.getState2(DartEntry.HINTS, entry.getKey()), CacheState.INVALID)) {
-            javaSetAdd(sources, entry.getKey());
-          }
-        } else if (sourceEntry is HtmlEntry) {
-          HtmlEntry htmlEntry = sourceEntry as HtmlEntry;
-          if (identical(htmlEntry.getState(HtmlEntry.ELEMENT), CacheState.INVALID)) {
-            javaSetAdd(sources, entry.getKey());
-          }
-        }
+        getSourcesNeedingProcessing2(entry.getKey(), entry.getValue(), false, hintsEnabled, sources);
       }
     }
     return new List<Source>.from(sources);
   }
   AnalysisContentStatistics get statistics {
     AnalysisContentStatisticsImpl statistics = new AnalysisContentStatisticsImpl();
     {
       for (MapEntry<Source, SourceEntry> mapEntry in _cache.entrySet()) {
         SourceEntry entry = mapEntry.getValue();
         if (entry is DartEntry) {
@@ skipping 10 matching lines @@
             statistics.putCacheItem(dartEntry, DartEntry.IMPORTED_LIBRARIES);
             statistics.putCacheItem(dartEntry, DartEntry.INCLUDED_PARTS);
             statistics.putCacheItem(dartEntry, DartEntry.IS_CLIENT);
             statistics.putCacheItem(dartEntry, DartEntry.IS_LAUNCHABLE);
           }
           List<Source> librarySources = getLibrariesContaining(source);
           for (Source librarySource in librarySources) {
             statistics.putCacheItem2(dartEntry, librarySource, DartEntry.HINTS);
             statistics.putCacheItem2(dartEntry, librarySource, DartEntry.RESOLUTION_ERRORS);
             statistics.putCacheItem2(dartEntry, librarySource, DartEntry.RESOLVED_UNIT);
+            statistics.putCacheItem2(dartEntry, librarySource, DartEntry.VERIFICATION_ERRORS);
           }
         }
       }
     }
     return statistics;
   }
   TimestampedData<CompilationUnit> internalResolveCompilationUnit(Source unitSource, LibraryElement libraryElement) {
     DartEntry dartEntry = getReadableDartEntry(unitSource);
     if (dartEntry == null) {
       throw new AnalysisException.con1("internalResolveCompilationUnit invoked for non-Dart file: ${unitSource.fullName}");
@@ skipping 241 matching lines @@
   DartEntry cacheDartResolutionData(Source unitSource, Source librarySource, DartEntry dartEntry, DataDescriptor descriptor) {
     CacheState state = (identical(descriptor, DartEntry.ELEMENT)) ? dartEntry.getState(descriptor) : dartEntry.getState2(descriptor, librarySource);
     while (state != CacheState.ERROR && state != CacheState.VALID) {
       dartEntry = new ResolveDartLibraryTask(this, unitSource, librarySource).perform(_resultRecorder) as DartEntry;
       state = (identical(descriptor, DartEntry.ELEMENT)) ? dartEntry.getState(descriptor) : dartEntry.getState2(descriptor, librarySource);
     }
     return dartEntry;
   }
 
   /**
+   * Given a source for a Dart file and the library that contains it, return a cache entry in which
+   * the data represented by the given descriptor is available. This method assumes that the data
+   * can be produced by verifying the source in the given library if the data is not already cached.
+   *
+   * @param unitSource the source representing the Dart file
+   * @param librarySource the source representing the library containing the Dart file
+   * @param dartEntry the cache entry associated with the Dart file
+   * @param descriptor the descriptor representing the data to be returned
+   * @return a cache entry containing the required data
+   * @throws AnalysisException if data could not be returned because the source could not be parsed
+   */
+  DartEntry cacheDartVerificationData(Source unitSource, Source librarySource, DartEntry dartEntry, DataDescriptor descriptor) {
+    CacheState state = dartEntry.getState2(descriptor, librarySource);
+    while (state != CacheState.ERROR && state != CacheState.VALID) {
+      dartEntry = new GenerateDartErrorsTask(this, unitSource, getLibraryElement(librarySource)).perform(_resultRecorder) as DartEntry;
+      state = dartEntry.getState2(descriptor, librarySource);
+    }
+    return dartEntry;
+  }
+
+  /**
    * Given a source for an HTML file, return a cache entry in which all of the data represented by
    * the given descriptors is available. This method assumes that the data can be produced by
    * parsing the source if it is not already cached.
    *
    * @param source the source representing the HTML file
    * @param htmlEntry the cache entry associated with the HTML file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
@@ skipping 212 matching lines @@
    */
   Object getDartResolutionData2(Source unitSource, Source librarySource, DataDescriptor descriptor, Object defaultValue) {
     DartEntry dartEntry = getReadableDartEntry(unitSource);
     if (dartEntry == null) {
       return defaultValue;
     }
     return getDartResolutionData(unitSource, librarySource, dartEntry, descriptor);
   }
 
   /**
+   * Given a source for a Dart file and the library that contains it, return the data represented by
+   * the given descriptor that is associated with that source. This method assumes that the data can
+   * be produced by verifying the source within the given library if it is not already cached.
+   *
+   * @param unitSource the source representing the Dart file
+   * @param librarySource the source representing the library containing the Dart file
+   * @param dartEntry the entry representing the Dart file
+   * @param descriptor the descriptor representing the data to be returned
+   * @return the requested data about the given source
+   * @throws AnalysisException if data could not be returned because the source could not be
+   *           resolved
+   */
+  Object getDartVerificationData(Source unitSource, Source librarySource, DartEntry dartEntry, DataDescriptor descriptor) {
+    dartEntry = cacheDartVerificationData(unitSource, librarySource, dartEntry, descriptor);
+    return dartEntry.getValue2(descriptor, librarySource);
+  }
+
+  /**
    * Given a source for an HTML file, return the data represented by the given descriptor that is
    * associated with that source, or the given default value if the source is not an HTML file. This
    * method assumes that the data can be produced by parsing the source if it is not already cached.
    *
    * @param source the source representing the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @param defaultValue the value to be returned if the source is not an HTML file
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be parsed
    */
@@ skipping 45 matching lines @@
   }
 
   /**
    * Look through the cache for a task that needs to be performed. Return the task that was found,
    * or `null` if there is no more work to be done.
    *
    * @return the next task that needs to be performed
    */
   AnalysisTask get nextTaskAnalysisTask {
     {
-      bool enableHints = analysisOptions.hint;
+      bool hintsEnabled = analysisOptions.hint;
       for (Source source in _cache.priorityOrder) {
-        SourceEntry sourceEntry = _cache.get(source);
-        if (sourceEntry is DartEntry) {
-          DartEntry dartEntry = sourceEntry as DartEntry;
-          CacheState parseErrorsState = dartEntry.getState(DartEntry.PARSE_ERRORS);
-          if (identical(parseErrorsState, CacheState.INVALID) || identical(parseErrorsState, CacheState.FLUSHED)) {
-            DartEntryImpl dartCopy = dartEntry.writableCopy;
-            dartCopy.setState(DartEntry.PARSE_ERRORS, CacheState.IN_PROCESS);
-            _cache.put(source, dartCopy);
-            return new ParseDartTask(this, source);
-          }
-          CompilationUnit parseUnit = dartEntry.anyParsedCompilationUnit;
-          if (parseUnit == null) {
-            DartEntryImpl dartCopy = dartEntry.writableCopy;
-            dartCopy.setState(DartEntry.PARSED_UNIT, CacheState.IN_PROCESS);
-            _cache.put(source, dartCopy);
-            return new ParseDartTask(this, source);
-          }
-          for (Source librarySource in getLibrariesContaining(source)) {
-            SourceEntry libraryEntry = _cache.get(librarySource);
-            if (libraryEntry is DartEntry) {
-              CacheState elementState = libraryEntry.getState(DartEntry.ELEMENT);
-              if (identical(elementState, CacheState.INVALID) || identical(elementState, CacheState.FLUSHED)) {
-                DartEntryImpl libraryCopy = ((libraryEntry as DartEntry)).writableCopy;
-                libraryCopy.setState(DartEntry.ELEMENT, CacheState.IN_PROCESS);
-                _cache.put(librarySource, libraryCopy);
-                return new ResolveDartLibraryTask(this, source, librarySource);
-              }
-              CacheState resolvedUnitState = dartEntry.getState2(DartEntry.RESOLVED_UNIT, librarySource);
-              if (identical(resolvedUnitState, CacheState.INVALID) || identical(resolvedUnitState, CacheState.FLUSHED)) {
-                LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
-                if (libraryElement != null) {
-                  DartEntryImpl dartCopy = dartEntry.writableCopy;
-                  dartCopy.setState2(DartEntry.RESOLVED_UNIT, librarySource, CacheState.IN_PROCESS);
-                  _cache.put(source, dartCopy);
-                  return new ResolveDartUnitTask(this, source, libraryElement);
-                }
-              }
-              CacheState hintsState = dartEntry.getState2(DartEntry.HINTS, librarySource);
-              if (enableHints && (identical(hintsState, CacheState.INVALID) || identical(hintsState, CacheState.FLUSHED))) {
-                LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
-                if (libraryElement != null) {
-                  DartEntryImpl dartCopy = dartEntry.writableCopy;
-                  dartCopy.setState2(DartEntry.HINTS, librarySource, CacheState.IN_PROCESS);
-                  _cache.put(source, dartCopy);
-                  return new GenerateDartHintsTask(this, libraryElement);
-                }
-              }
-            }
-          }
-        } else if (sourceEntry is HtmlEntry) {
-          HtmlEntry htmlEntry = sourceEntry as HtmlEntry;
-          CacheState parsedUnitState = htmlEntry.getState(HtmlEntry.PARSED_UNIT);
-          if (identical(parsedUnitState, CacheState.INVALID) || identical(parsedUnitState, CacheState.FLUSHED)) {
-            HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-            htmlCopy.setState(HtmlEntry.PARSED_UNIT, CacheState.IN_PROCESS);
-            _cache.put(source, htmlCopy);
-            return new ParseHtmlTask(this, source);
-          }
-          CacheState elementState = htmlEntry.getState(HtmlEntry.ELEMENT);
-          if (identical(elementState, CacheState.INVALID) || identical(elementState, CacheState.FLUSHED)) {
-            HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-            htmlCopy.setState(HtmlEntry.ELEMENT, CacheState.IN_PROCESS);
-            _cache.put(source, htmlCopy);
-            return new ResolveHtmlTask(this, source);
-          }
+        AnalysisTask task = getNextTaskAnalysisTask2(source, _cache.get(source), true, hintsEnabled);
+        if (task != null) {
+          return task;
         }
       }
       for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
-        SourceEntry sourceEntry = entry.getValue();
-        if (sourceEntry is DartEntry) {
-          DartEntry dartEntry = sourceEntry as DartEntry;
-          if (identical(dartEntry.getState(DartEntry.PARSED_UNIT), CacheState.INVALID)) {
-            Source source = entry.getKey();
-            DartEntryImpl dartCopy = dartEntry.writableCopy;
-            dartCopy.setState(DartEntry.PARSE_ERRORS, CacheState.IN_PROCESS);
-            _cache.put(source, dartCopy);
-            return new ParseDartTask(this, source);
-          }
-        } else if (sourceEntry is HtmlEntry) {
-          HtmlEntry htmlEntry = sourceEntry as HtmlEntry;
-          if (identical(htmlEntry.getState(HtmlEntry.PARSED_UNIT), CacheState.INVALID)) {
-            Source source = entry.getKey();
-            HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-            htmlCopy.setState(HtmlEntry.PARSED_UNIT, CacheState.IN_PROCESS);
-            _cache.put(source, htmlCopy);
-            return new ParseHtmlTask(this, source);
-          }
-        }
-      }
-      for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
-        SourceEntry sourceEntry = entry.getValue();
-        if (sourceEntry is DartEntry) {
-          Source source = entry.getKey();
-          DartEntry dartEntry = sourceEntry as DartEntry;
-          if (identical(dartEntry.kind, SourceKind.LIBRARY) && identical(dartEntry.getState(DartEntry.ELEMENT), CacheState.INVALID)) {
-            DartEntryImpl dartCopy = dartEntry.writableCopy;
-            dartCopy.setState(DartEntry.ELEMENT, CacheState.IN_PROCESS);
-            _cache.put(source, dartCopy);
-            return new ResolveDartLibraryTask(this, source, source);
-          } else if (enableHints && identical(dartEntry.getState2(DartEntry.HINTS, source), CacheState.INVALID)) {
-            LibraryElement libraryElement = dartEntry.getValue(DartEntry.ELEMENT);
-            if (libraryElement != null) {
-              DartEntryImpl dartCopy = dartEntry.writableCopy;
-              dartCopy.setState2(DartEntry.HINTS, source, CacheState.IN_PROCESS);
-              _cache.put(source, dartCopy);
-              return new GenerateDartHintsTask(this, libraryElement);
-            }
-          }
-        } else if (sourceEntry is HtmlEntry) {
-          HtmlEntry htmlEntry = sourceEntry as HtmlEntry;
-          if (identical(htmlEntry.getState(HtmlEntry.ELEMENT), CacheState.INVALID)) {
-            Source source = entry.getKey();
-            HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-            htmlCopy.setState(HtmlEntry.ELEMENT, CacheState.IN_PROCESS);
-            _cache.put(source, htmlCopy);
-            return new ResolveHtmlTask(this, source);
-          }
+        AnalysisTask task = getNextTaskAnalysisTask2(entry.getKey(), entry.getValue(), false, hintsEnabled);
+        if (task != null) {
+          return task;
         }
       }
       return null;
     }
   }
 
   /**
+   * Look at the given source to see whether a task needs to be performed related to it. Return the
+   * task that should be performed, or `null` if there is no more work to be done for the
+   * source.
+   *
+   * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
+   *
+   * @param source the source to be checked
+   * @param sourceEntry the cache entry associated with the source
+   * @param isPriority `true` if the source is a priority source
+   * @param hintsEnabled `true` if hints are currently enabled
+   * @return the next task that needs to be performed for the given source
+   */
+  AnalysisTask getNextTaskAnalysisTask2(Source source, SourceEntry sourceEntry, bool isPriority, bool hintsEnabled) {
+    if (sourceEntry is DartEntry) {
+      DartEntry dartEntry = sourceEntry as DartEntry;
+      CacheState parseErrorsState = dartEntry.getState(DartEntry.PARSE_ERRORS);
+      if (identical(parseErrorsState, CacheState.INVALID) || (isPriority && identical(parseErrorsState, CacheState.FLUSHED))) {
+        DartEntryImpl dartCopy = dartEntry.writableCopy;
+        dartCopy.setState(DartEntry.PARSE_ERRORS, CacheState.IN_PROCESS);
+        _cache.put(source, dartCopy);
+        return new ParseDartTask(this, source);
+      }
+      if (isPriority) {
+        CompilationUnit parseUnit = dartEntry.anyParsedCompilationUnit;
+        if (parseUnit == null) {
+          DartEntryImpl dartCopy = dartEntry.writableCopy;
+          dartCopy.setState(DartEntry.PARSED_UNIT, CacheState.IN_PROCESS);
+          _cache.put(source, dartCopy);
+          return new ParseDartTask(this, source);
+        }
+      }
+      for (Source librarySource in getLibrariesContaining(source)) {
+        SourceEntry libraryEntry = _cache.get(librarySource);
+        if (libraryEntry is DartEntry) {
+          CacheState elementState = libraryEntry.getState(DartEntry.ELEMENT);
+          if (identical(elementState, CacheState.INVALID) || (isPriority && identical(elementState, CacheState.FLUSHED))) {
+            DartEntryImpl libraryCopy = ((libraryEntry as DartEntry)).writableCopy;
+            libraryCopy.setState(DartEntry.ELEMENT, CacheState.IN_PROCESS);
+            _cache.put(librarySource, libraryCopy);
+            return new ResolveDartLibraryTask(this, source, librarySource);
+          }
+          CacheState resolvedUnitState = dartEntry.getState2(DartEntry.RESOLVED_UNIT, librarySource);
+          if (identical(resolvedUnitState, CacheState.INVALID) || (isPriority && identical(resolvedUnitState, CacheState.FLUSHED))) {
+            LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
+            if (libraryElement != null) {
+              DartEntryImpl dartCopy = dartEntry.writableCopy;
+              dartCopy.setState2(DartEntry.RESOLVED_UNIT, librarySource, CacheState.IN_PROCESS);
+              _cache.put(source, dartCopy);
+              return new ResolveDartUnitTask(this, source, libraryElement);
+            }
+          }
+          CacheState verificationErrorsState = dartEntry.getState2(DartEntry.VERIFICATION_ERRORS, librarySource);
+          if (identical(verificationErrorsState, CacheState.INVALID) || (isPriority && identical(verificationErrorsState, CacheState.FLUSHED))) {
+            LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
+            if (libraryElement != null) {
+              DartEntryImpl dartCopy = dartEntry.writableCopy;
+              dartCopy.setState2(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.IN_PROCESS);
+              _cache.put(source, dartCopy);
+              return new GenerateDartErrorsTask(this, source, libraryElement);
+            }
+          }
+          if (hintsEnabled) {
+            CacheState hintsState = dartEntry.getState2(DartEntry.HINTS, librarySource);
+            if (identical(hintsState, CacheState.INVALID) || (isPriority && identical(hintsState, CacheState.FLUSHED))) {
+              LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
+              if (libraryElement != null) {
+                DartEntryImpl dartCopy = dartEntry.writableCopy;
+                dartCopy.setState2(DartEntry.HINTS, librarySource, CacheState.IN_PROCESS);
+                _cache.put(source, dartCopy);
+                return new GenerateDartHintsTask(this, libraryElement);
+              }
+            }
+          }
+        }
+      }
+    } else if (sourceEntry is HtmlEntry) {
+      HtmlEntry htmlEntry = sourceEntry as HtmlEntry;
+      CacheState parsedUnitState = htmlEntry.getState(HtmlEntry.PARSED_UNIT);
+      if (identical(parsedUnitState, CacheState.INVALID) || (isPriority && identical(parsedUnitState, CacheState.FLUSHED))) {
+        HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
+        htmlCopy.setState(HtmlEntry.PARSED_UNIT, CacheState.IN_PROCESS);
+        _cache.put(source, htmlCopy);
+        return new ParseHtmlTask(this, source);
+      }
+      CacheState elementState = htmlEntry.getState(HtmlEntry.ELEMENT);
+      if (identical(elementState, CacheState.INVALID) || (isPriority && identical(elementState, CacheState.FLUSHED))) {
+        HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
+        htmlCopy.setState(HtmlEntry.ELEMENT, CacheState.IN_PROCESS);
+        _cache.put(source, htmlCopy);
+        return new ResolveHtmlTask(this, source);
+      }
+    }
+    return null;
+  }
+
+  /**
    * Return a change notice for the given source, creating one if one does not already exist.
    *
    * @param source the source for which changes are being reported
    * @return a change notice for the given source
    */
   ChangeNoticeImpl getNotice(Source source) {
     ChangeNoticeImpl notice = _pendingNotices[source];
     if (notice == null) {
       notice = new ChangeNoticeImpl(source);
       _pendingNotices[source] = notice;
@@ skipping 75 matching lines @@
       for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
         if (identical(entry.getValue().kind, kind)) {
           sources.add(entry.getKey());
         }
       }
     }
     return new List.from(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 duplicates, and must
+   * therefore be kept in sync with,
+   * [getNextTaskAnalysisTask]. This method is
+   * intended to be used for testing purposes only.
+   *
+   * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
+   *
+   * @param source the source to be checked
+   * @param sourceEntry the cache entry associated with the source
+   * @param isPriority `true` if the source is a priority source
+   * @param hintsEnabled `true` if hints are currently enabled
+   * @param sources the set to which sources should be added
+   */
+  void getSourcesNeedingProcessing2(Source source, SourceEntry sourceEntry, bool isPriority, bool hintsEnabled, Set<Source> sources) {
+    if (sourceEntry is DartEntry) {
+      DartEntry dartEntry = sourceEntry as DartEntry;
+      CacheState parseErrorsState = dartEntry.getState(DartEntry.PARSE_ERRORS);
+      if (identical(parseErrorsState, CacheState.INVALID) || (isPriority && identical(parseErrorsState, CacheState.FLUSHED))) {
+        javaSetAdd(sources, source);
+        return;
+      }
+      if (isPriority) {
+        CompilationUnit parseUnit = dartEntry.anyParsedCompilationUnit;
+        if (parseUnit == null) {
+          javaSetAdd(sources, source);
+          return;
+        }
+      }
+      for (Source librarySource in getLibrariesContaining(source)) {
+        SourceEntry libraryEntry = _cache.get(librarySource);
+        if (libraryEntry is DartEntry) {
+          CacheState elementState = libraryEntry.getState(DartEntry.ELEMENT);
+          if (identical(elementState, CacheState.INVALID) || (isPriority && identical(elementState, CacheState.FLUSHED))) {
+            javaSetAdd(sources, source);
+            return;
+          }
+          CacheState resolvedUnitState = dartEntry.getState2(DartEntry.RESOLVED_UNIT, librarySource);
+          if (identical(resolvedUnitState, CacheState.INVALID) || (isPriority && identical(resolvedUnitState, CacheState.FLUSHED))) {
+            LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
+            if (libraryElement != null) {
+              javaSetAdd(sources, source);
+              return;
+            }
+          }
+          CacheState verificationErrorsState = dartEntry.getState2(DartEntry.VERIFICATION_ERRORS, librarySource);
+          if (identical(verificationErrorsState, CacheState.INVALID) || (isPriority && identical(verificationErrorsState, CacheState.FLUSHED))) {
+            LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
+            if (libraryElement != null) {
+              javaSetAdd(sources, source);
+              return;
+            }
+          }
+          if (hintsEnabled) {
+            CacheState hintsState = dartEntry.getState2(DartEntry.HINTS, librarySource);
+            if (identical(hintsState, CacheState.INVALID) || (isPriority && identical(hintsState, CacheState.FLUSHED))) {
+              LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
+              if (libraryElement != null) {
+                javaSetAdd(sources, source);
+                return;
+              }
+            }
+          }
+        }
+      }
+    } else if (sourceEntry is HtmlEntry) {
+      HtmlEntry htmlEntry = sourceEntry as HtmlEntry;
+      CacheState parsedUnitState = htmlEntry.getState(HtmlEntry.PARSED_UNIT);
+      if (identical(parsedUnitState, CacheState.INVALID) || (isPriority && identical(parsedUnitState, CacheState.FLUSHED))) {
+        javaSetAdd(sources, source);
+        return;
+      }
+      CacheState elementState = htmlEntry.getState(HtmlEntry.ELEMENT);
+      if (identical(elementState, CacheState.INVALID) || (isPriority && identical(elementState, CacheState.FLUSHED))) {
+        javaSetAdd(sources, source);
+        return;
+      }
+    }
+  }
+
+  /**
    * Invalidate all of the resolution results computed by this context.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    */
   void invalidateAllResolutionInformation() {
     for (MapEntry<Source, SourceEntry> mapEntry in _cache.entrySet()) {
       SourceEntry sourceEntry = mapEntry.getValue();
       if (sourceEntry is HtmlEntry) {
         HtmlEntryImpl htmlCopy = ((sourceEntry as HtmlEntry)).writableCopy;
         htmlCopy.invalidateAllResolutionInformation();
@@ skipping 77 matching lines @@
     List<Source> unitSources = new List<Source>();
     unitSources.add(library.definingCompilationUnit.source);
     for (CompilationUnitElement part in library.parts) {
       Source partSource = part.source;
       unitSources.add(partSource);
     }
     dartCopy.setValue(DartEntry.INCLUDED_PARTS, new List.from(unitSources));
   }
 
   /**
+   * Record the results produced by performing a [GenerateDartErrorsTask]. If the results were
+   * computed from data that is now out-of-date, then the results will not be recorded.
+   *
+   * @param task the task that was performed
+   * @return an entry containing the computed results
+   * @throws AnalysisException if the results could not be recorded
+   */
+  DartEntry recordGenerateDartErrorsTask(GenerateDartErrorsTask task) {
+    Source source = task.source;
+    Source librarySource = task.libraryElement.source;
+    AnalysisException thrownException = task.exception;
+    DartEntry dartEntry = null;
+    {
+      SourceEntry sourceEntry = _cache.get(source);
+      if (sourceEntry is! DartEntry) {
+        throw new AnalysisException.con1("Internal error: attempting to verify non-Dart file as a Dart file: ${source.fullName}");
+      }
+      dartEntry = sourceEntry as DartEntry;
+      _cache.accessed(source);
+      int sourceTime = source.modificationStamp;
+      int resultTime = task.modificationTime;
+      if (sourceTime == resultTime) {
+        if (dartEntry.modificationTime != sourceTime) {
+          sourceChanged(source);
+          dartEntry = getReadableDartEntry(source);
+          if (dartEntry == null) {
+            throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
+          }
+        }
+        DartEntryImpl dartCopy = dartEntry.writableCopy;
+        if (thrownException == null) {
+          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 {
+        DartEntryImpl dartCopy = dartEntry.writableCopy;
+        if (thrownException == null || resultTime >= 0) {
+          dartCopy.setState2(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.INVALID);
+        } else {
+          dartCopy.setState2(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.ERROR);
+        }
+        dartCopy.exception = thrownException;
+        _cache.put(source, dartCopy);
+        dartEntry = dartCopy;
+      }
+    }
+    if (thrownException != null) {
+      throw thrownException;
+    }
+    return dartEntry;
+  }
+
+  /**
    * Record the results produced by performing a [GenerateDartHintsTask]. If the results were
    * computed from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   DartEntry recordGenerateDartHintsTask(GenerateDartHintsTask task) {
     Source librarySource = task.libraryElement.source;
     AnalysisException thrownException = task.exception;
@@ skipping 106 matching lines @@
           if (task.hasPartOfDirective() && !task.hasLibraryDirective()) {
             dartCopy.setValue(DartEntry.SOURCE_KIND, SourceKind.PART);
           } else {
             dartCopy.setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY);
           }
           dartCopy.setValue(DartEntry.PARSED_UNIT, task.compilationUnit);
           dartCopy.setValue(DartEntry.PARSE_ERRORS, task.errors);
           dartCopy.setValue(DartEntry.EXPORTED_LIBRARIES, task.exportedSources);
           dartCopy.setValue(DartEntry.IMPORTED_LIBRARIES, task.importedSources);
           dartCopy.setValue(DartEntry.INCLUDED_PARTS, task.includedSources);
+          ChangeNoticeImpl notice = getNotice(source);
+          notice.setErrors(dartEntry.allErrors, lineInfo);
         } else {
           dartCopy.recordParseError();
         }
         dartCopy.exception = thrownException;
         _cache.put(source, dartCopy);
         dartEntry = dartCopy;
       } else {
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         if (thrownException == null || resultTime >= 0) {
           dartCopy.recordParseNotInProcess();
@@ skipping 325 matching lines @@
    */
   void sourceChanged(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry is HtmlEntry) {
       HtmlEntryImpl htmlCopy = ((sourceEntry as HtmlEntry)).writableCopy;
       htmlCopy.modificationTime = source.modificationStamp;
       htmlCopy.invalidateAllInformation();
       _cache.put(source, htmlCopy);
     } else if (sourceEntry is DartEntry) {
       List<Source> containingLibraries = getLibrariesContaining(source);
-      for (Source library in containingLibraries) {
+      Set<Source> librariesToInvalidate = new Set<Source>();
+      for (Source containingLibrary in containingLibraries) {
+        javaSetAdd(librariesToInvalidate, containingLibrary);
+        for (Source dependentLibrary in getLibrariesDependingOn(containingLibrary)) {
+          javaSetAdd(librariesToInvalidate, dependentLibrary);
+        }
+      }
+      for (Source library in librariesToInvalidate) {
         invalidateLibraryResolution(library);
       }
       DartEntryImpl dartCopy = ((sourceEntry as DartEntry)).writableCopy;
       dartCopy.modificationTime = source.modificationStamp;
       dartCopy.invalidateAllInformation();
       _cache.put(source, dartCopy);
     }
   }
 
   /**
@@ skipping 18 matching lines @@
     _cache.remove(source);
   }
 }
 /**
  * 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;
   AnalysisContextImpl_AnalysisTaskResultRecorder(this.AnalysisContextImpl_this);
+  SourceEntry visitGenerateDartErrorsTask(GenerateDartErrorsTask task) => AnalysisContextImpl_this.recordGenerateDartErrorsTask(task);
   SourceEntry visitGenerateDartHintsTask(GenerateDartHintsTask task) => AnalysisContextImpl_this.recordGenerateDartHintsTask(task);
   DartEntry visitParseDartTask(ParseDartTask task) => AnalysisContextImpl_this.recordParseDartTaskResults(task);
   HtmlEntry visitParseHtmlTask(ParseHtmlTask task) => AnalysisContextImpl_this.recordParseHtmlTaskResults(task);
   DartEntry visitResolveDartLibraryTask(ResolveDartLibraryTask task) => AnalysisContextImpl_this.recordResolveDartLibraryTaskResults(task);
   SourceEntry visitResolveDartUnitTask(ResolveDartUnitTask task) => AnalysisContextImpl_this.recordResolveDartUnitTaskResults(task);
   SourceEntry visitResolveHtmlTask(ResolveHtmlTask task) => AnalysisContextImpl_this.recordResolveHtmlTaskResults(task);
 }
 /**
  * Instances of the class `AnalysisErrorInfoImpl` represent the analysis errors and line info
  * associated with a source.
@@ skipping 186 matching lines @@
    * Set the errors that changed as a result of the analysis to the given errors and set the line
    * information to the given line information.
    *
    * @param errors the errors that changed as a result of the analysis
    * @param lineInfo the line information associated with the source
    */
   void setErrors(List<AnalysisError> errors, LineInfo lineInfo) {
     this._errors = errors;
     this._lineInfo = lineInfo;
   }
+  String toString() => "Changes for ${_source.fullName}";
 }
 /**
  * Instances of the class `DelegatingAnalysisContextImpl` extend [AnalysisContextImpl
  ] to delegate sources to the appropriate analysis context. For instance, if the
  * source is in a system library then the analysis context from the [DartSdk] is used.
  *
  * @coverage dart.engine
  */
 class DelegatingAnalysisContextImpl extends AnalysisContextImpl {
 
@@ skipping 1161 matching lines @@
    * Perform this analysis task, ensuring that all exceptions are wrapped in an
    * [AnalysisException].
    *
    * @throws AnalysisException if any exception occurs while performing the task
    */
   void safelyPerform() {
     try {
       internalPerform();
     } on AnalysisException catch (exception) {
       throw exception;
-    } catch (exception) {
+    } on JavaException catch (exception) {
       throw new AnalysisException.con3(exception);
     }
   }
 }
 /**
  * The interface `AnalysisTaskVisitor` defines the behavior of objects that can visit tasks.
  * While tasks are not structured in any interesting way, this class provides the ability to
  * dispatch to an appropriate method.
  */
 abstract class AnalysisTaskVisitor<E> {
 
   /**
+   * Visit a [GenerateDartErrorsTask].
+   *
+   * @param task the task to be visited
+   * @return the result of visiting the task
+   * @throws AnalysisException if the visitor throws an exception for some reason
+   */
+  E visitGenerateDartErrorsTask(GenerateDartErrorsTask task);
+
+  /**
    * Visit a [GenerateDartHintsTask].
    *
    * @param task the task to be visited
    * @return the result of visiting the task
    * @throws AnalysisException if the visitor throws an exception for some reason
    */
   E visitGenerateDartHintsTask(GenerateDartHintsTask task);
 
   /**
    * Visit a [ParseDartTask].
@@ skipping 34 matching lines @@
   /**
    * Visit a [ResolveHtmlTask].
    *
    * @param task the task to be visited
    * @return the result of visiting the task
    * @throws AnalysisException if the visitor throws an exception for some reason
    */
   E visitResolveHtmlTask(ResolveHtmlTask task);
 }
 /**
+ * Instances of the class `GenerateDartErrorsTask` generate errors and warnings for a single
+ * Dart source.
+ */
+class GenerateDartErrorsTask extends AnalysisTask {
+
+  /**
+   * The source for which errors and warnings are to be produced.
+   */
+  Source source;
+
+  /**
+   * The element model for the library containing the source.
+   */
+  LibraryElement libraryElement;
+
+  /**
+   * The time at which the contents of the source were last modified.
+   */
+  int modificationTime = -1;
+
+  /**
+   * The errors that were generated for the source.
+   */
+  List<AnalysisError> errors;
+
+  /**
+   * Initialize a newly created task to perform analysis within the given context.
+   *
+   * @param context the context in which the task is to be performed
+   * @param source the source for which errors and warnings are to be produced
+   * @param libraryElement the element model for the library containing the source
+   */
+  GenerateDartErrorsTask(InternalAnalysisContext context, Source source, LibraryElement libraryElement) : super(context) {
+    this.source = source;
+    this.libraryElement = libraryElement;
+  }
+  accept(AnalysisTaskVisitor visitor) => visitor.visitGenerateDartErrorsTask(this);
+  String get taskDescription => "generate errors and warnings for ${source.fullName}";
+  void internalPerform() {
+    TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.errors.start();
+    try {
+      InternalAnalysisContext context = this.context;
+      TimestampedData<CompilationUnit> data = context.internalResolveCompilationUnit(source, libraryElement);
+      modificationTime = data.modificationTime;
+      CompilationUnit unit = data.data;
+      RecordingErrorListener errorListener = new RecordingErrorListener();
+      ErrorReporter errorReporter = new ErrorReporter(errorListener, source);
+      Source coreSource = context.sourceFactory.forUri(DartSdk.DART_CORE);
+      LibraryElement coreLibrary = context.getLibraryElement(coreSource);
+      TypeProvider typeProvider = new TypeProviderImpl(coreLibrary);
+      ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, typeProvider);
+      unit.accept(constantVerifier);
+      ErrorVerifier errorVerifier = new ErrorVerifier(errorReporter, libraryElement, typeProvider, new InheritanceManager(libraryElement));
+      unit.accept(errorVerifier);
+      errors = errorListener.getErrors2(source);
+    } finally {
+      timeCounter.stop();
+    }
+  }
+}
+/**
  * Instances of the class `GenerateDartHintsTask` generate hints for a single Dart library.
  */
 class GenerateDartHintsTask extends AnalysisTask {
 
   /**
    * The element model for the library being analyzed.
    */
   LibraryElement libraryElement;
 
   /**
@@ skipping 167 matching lines @@
     }
     return "parse as dart ${source.fullName}";
   }
   void internalPerform() {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     List<Token> token = [null];
     TimeCounter_TimeCounterHandle timeCounterScan = PerformanceStatistics.scan.start();
     Source_ContentReceiver receiver = new Source_ContentReceiver_9(this, errorListener, token);
     try {
       source.getContents(receiver);
-    } catch (exception) {
+    } on JavaException catch (exception) {
       modificationTime = source.modificationStamp;
       throw new AnalysisException.con3(exception);
     }
     timeCounterScan.stop();
     TimeCounter_TimeCounterHandle timeCounterParse = PerformanceStatistics.parse.start();
     Parser parser = new Parser(source, errorListener);
     compilationUnit = parser.parseCompilationUnit(token[0]);
     errors = errorListener.getErrors2(source);
     for (Directive directive in compilationUnit.directives) {
       if (directive is ExportDirective) {
@@ skipping 144 matching lines @@
   String get taskDescription {
     if (source == null) {
       return "parse as html null source";
     }
     return "parse as html ${source.fullName}";
   }
   void internalPerform() {
     HtmlScanner scanner = new HtmlScanner(source);
     try {
       source.getContents(scanner);
-    } catch (exception) {
+    } on JavaException catch (exception) {
       throw new AnalysisException.con3(exception);
     }
     HtmlScanResult scannerResult = scanner.result;
     modificationTime = scannerResult.modificationTime;
     lineInfo = new LineInfo(scannerResult.lineStarts);
     HtmlParseResult result = new HtmlParser(source).parse(scannerResult);
     htmlUnit = result.htmlUnit;
     referencedLibraries = librarySources;
   }
 
@@ skipping 26 matching lines @@
           if (javaStringEqualsIgnoreCase(attribute.text, ParseHtmlTask._TYPE_DART)) {
             isDartScript = true;
           }
         }
       }
       if (isDartScript && scriptAttribute != null) {
         try {
           Uri uri = new Uri(path: scriptAttribute.text);
           String fileName = uri.path;
           Source librarySource = ParseHtmlTask_this.context.sourceFactory.resolveUri(ParseHtmlTask_this.source, fileName);
-          if (librarySource.exists()) {
+          if (librarySource != null && librarySource.exists()) {
             libraries.add(librarySource);
           }
-        } catch (exception) {
-          AnalysisEngine.instance.logger.logInformation2("Invalid URL ('${scriptAttribute.text}') in script tag in '${ParseHtmlTask_this.source.fullName}'", exception);
+        } on URISyntaxException catch (e) {
         }
       }
     }
     return super.visitXmlTagNode(node);
   }
 }
 /**
  * Instances of the class `ResolveDartLibraryTask` parse a specific Dart library.
  */
 class ResolveDartLibraryTask extends AnalysisTask {
@@ skipping 253 matching lines @@
   }
   void logError2(String message, Exception exception) {
   }
   void logError3(Exception exception) {
   }
   void logInformation(String message) {
   }
   void logInformation2(String message, Exception exception) {
   }
 }