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 56 matching lines @@
     int count = _partitions.length;
     for (int i = 0; i < count; i++) {
       if (_partitions[i].contains(source)) {
         return _partitions[i].get(source);
       }
     }
     return null;
   }
 
   /**
+   * Return the number of entries in this cache that have an AST associated with them.
+   *
+   * @return the number of entries in this cache that have an AST associated with them
+   */
+  int get astSize => _partitions[_partitions.length - 1].astSize;
+
+  /**
+   * Return information about each of the partitions in this cache.
+   *
+   * @return information about each of the partitions in this cache
+   */
+  List<AnalysisContextStatistics_PartitionData> get partitionData {
+    int count = _partitions.length;
+    List<AnalysisContextStatistics_PartitionData> data = new List<AnalysisContextStatistics_PartitionData>(count);
+    for (int i = 0; i < count; i++) {
+      CachePartition partition = _partitions[i];
+      data[i] = new AnalysisContextStatisticsImpl_PartitionDataImpl(partition.astSize, partition.map.length);
+    }
+    return data;
+  }
+
+  /**
    * Return an iterator returning all of the map entries mapping sources to cache entries.
    *
    * @return an iterator returning all of the map entries mapping sources to cache entries
    */
   MapIterator<Source, SourceEntry> iterator() {
     int count = _partitions.length;
     List<Map<Source, SourceEntry>> maps = new List<Map>(count);
     for (int i = 0; i < count; i++) {
       maps[i] = _partitions[i].map;
     }
@@ skipping 71 matching lines @@
     for (int i = 0; i < count; i++) {
       if (_partitions[i].contains(source)) {
         _partitions[i].storedAst(source);
         return;
       }
     }
   }
 }
 
 /**
- * Container with statistics about the [AnalysisContext].
- */
-abstract class AnalysisContentStatistics {
-  /**
-   * Return the statistics for each kind of cached data.
-   *
-   * @return the statistics for each kind of cached data
-   */
-  List<AnalysisContentStatistics_CacheRow> get cacheRows;
-
-  /**
-   * Return the exceptions that caused some entries to have a state of [CacheState#ERROR].
-   *
-   * @return the exceptions that caused some entries to have a state of [CacheState#ERROR]
-   */
-  List<AnalysisException> get exceptions;
-
-  /**
-   * Return an array containing all of the sources in the cache.
-   *
-   * @return an array containing all of the sources in the cache
-   */
-  List<Source> get sources;
-}
-
-/**
- * Implementation of the [AnalysisContentStatistics].
- */
-class AnalysisContentStatisticsImpl implements AnalysisContentStatistics {
-  Map<String, AnalysisContentStatistics_CacheRow> _dataMap = new Map<String, AnalysisContentStatistics_CacheRow>();
-
-  List<Source> _sources = new List<Source>();
-
-  Set<AnalysisException> _exceptions = new Set<AnalysisException>();
-
-  void addSource(Source source) {
-    _sources.add(source);
-  }
-
-  @override
-  List<AnalysisContentStatistics_CacheRow> get cacheRows {
-    Iterable<AnalysisContentStatistics_CacheRow> items = _dataMap.values;
-    return new List.from(items);
-  }
-
-  @override
-  List<AnalysisException> get exceptions => new List.from(_exceptions);
-
-  @override
-  List<Source> get sources => new List.from(_sources);
-
-  void putCacheItem(SourceEntry dartEntry, DataDescriptor descriptor) {
-    _internalPutCacheItem(dartEntry, descriptor, dartEntry.getState(descriptor));
-  }
-
-  void putCacheItemInLibrary(DartEntry dartEntry, Source librarySource, DataDescriptor descriptor) {
-    _internalPutCacheItem(dartEntry, descriptor, dartEntry.getStateInLibrary(descriptor, librarySource));
-  }
-
-  void _internalPutCacheItem(SourceEntry dartEntry, DataDescriptor rowDesc, CacheState state) {
-    String rowName = rowDesc.toString();
-    AnalysisContentStatisticsImpl_CacheRowImpl row = _dataMap[rowName] as AnalysisContentStatisticsImpl_CacheRowImpl;
-    if (row == null) {
-      row = new AnalysisContentStatisticsImpl_CacheRowImpl(rowName);
-      _dataMap[rowName] = row;
-    }
-    row._incState(state);
-    if (state == CacheState.ERROR) {
-      AnalysisException exception = dartEntry.exception;
-      if (exception != null) {
-        _exceptions.add(exception);
-      }
-    }
-  }
-}
-
-class AnalysisContentStatisticsImpl_CacheRowImpl implements AnalysisContentStatistics_CacheRow {
-  final String name;
-
-  int _errorCount = 0;
-
-  int _flushedCount = 0;
-
-  int _inProcessCount = 0;
-
-  int _invalidCount = 0;
-
-  int _validCount = 0;
-
-  AnalysisContentStatisticsImpl_CacheRowImpl(this.name);
-
-  @override
-  bool operator ==(Object obj) => obj is AnalysisContentStatisticsImpl_CacheRowImpl && obj.name == name;
-
-  @override
-  int get errorCount => _errorCount;
-
-  @override
-  int get flushedCount => _flushedCount;
-
-  @override
-  int get inProcessCount => _inProcessCount;
-
-  @override
-  int get invalidCount => _invalidCount;
-
-  @override
-  int get validCount => _validCount;
-
-  @override
-  int get hashCode => name.hashCode;
-
-  void _incState(CacheState state) {
-    if (state == CacheState.ERROR) {
-      _errorCount++;
-    }
-    if (state == CacheState.FLUSHED) {
-      _flushedCount++;
-    }
-    if (state == CacheState.IN_PROCESS) {
-      _inProcessCount++;
-    }
-    if (state == CacheState.INVALID) {
-      _invalidCount++;
-    }
-    if (state == CacheState.VALID) {
-      _validCount++;
-    }
-  }
-}
-
-/**
- * Information about single item in the cache.
- */
-abstract class AnalysisContentStatistics_CacheRow {
-  int get errorCount;
-
-  int get flushedCount;
-
-  int get inProcessCount;
-
-  int get invalidCount;
-
-  String get name;
-
-  int get validCount;
-}
-
-/**
  * The interface `AnalysisContext` defines the behavior of objects that represent a context in
  * which a single analysis can be performed and incrementally maintained. The context includes such
  * information as the version of the SDK being analyzed against as well as the package-root used to
  * resolve 'package:' URI's. (Both of which are known indirectly through the [SourceFactory
  ].)
  *
  * An analysis context also represents the state of the analysis, which includes knowing which
  * sources have been included in the analysis (either directly or indirectly) and the results of the
  * analysis. Sources must be added and removed from the context using the method
  * [applyChanges], which is also used to notify the context when sources have been
@@ skipping 15 matching lines @@
  * needed analysis and get notified of the consequent changes to the analysis results. This
  * mechanism is realized by the method [performAnalysisTask].
  *
  * Analysis engine allows for having more than one context. This can be used, for example, to
  * perform one analysis based on the state of files on disk and a separate analysis based on the
  * state of those files in open editors. It can also be used to perform an analysis based on a
  * proposed future state, such as the state after a refactoring.
  */
 abstract class AnalysisContext {
   /**
+   * Apply the given delta to change the level of analysis that will be performed for the sources
+   * known to this context.
+   *
+   * @param delta a description of the level of analysis that should be performed for some sources
+   */
+  void applyAnalysisDelta(AnalysisDelta delta);
+
+  /**
    * Apply the changes specified by the given change set to this context. Any analysis results that
    * have been invalidated by these changes will be removed.
    *
    * @param changeSet a description of the changes that are to be applied
    */
   void applyChanges(ChangeSet changeSet);
 
   /**
    * Return the documentation comment for the given element as it appears in the original source
    * (complete with the beginning and ending delimiters), or `null` if the element does not
@@ skipping 653 matching lines @@
    * The set of [AngularApplication] in this context.
    */
   Set<AngularApplication> _angularApplications = new Set();
 
   /**
    * Initialize a newly created analysis context.
    */
   AnalysisContextImpl() : super() {
     _resultRecorder = new AnalysisContextImpl_AnalysisTaskResultRecorder(this);
     _privatePartition = new UniversalCachePartition(AnalysisOptionsImpl.DEFAULT_CACHE_SIZE, new AnalysisContextImpl_ContextRetentionPolicy(this));
-    _cache = _createCacheFromSourceFactory(null);
+    _cache = createCacheFromSourceFactory(null);
   }
 
   @override
   void addSourceInfo(Source source, SourceEntry info) {
     // 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);
   }
 
   @override
+  void applyAnalysisDelta(AnalysisDelta delta) {
+    ChangeSet changeSet = new ChangeSet();
+    for (MapEntry<Source, AnalysisLevel> entry in getMapEntrySet(delta.analysisLevels)) {
+      Source source = entry.getKey();
+      if (entry.getValue() == AnalysisLevel.NONE) {
+        changeSet.removedSource(source);
+      } else {
+        changeSet.addedSource(source);
+      }
+    }
+    applyChanges(changeSet);
+  }
+
+  @override
   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.removedSources);
     for (SourceContainer container in changeSet.removedContainers) {
@@ skipping 576 matching lines @@
     // Look for non-priority sources that need to be analyzed.
     //
     MapIterator<Source, SourceEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       _getSourcesNeedingProcessing(iterator.key, iterator.value, false, hintsEnabled, sources);
     }
     return new List<Source>.from(sources);
   }
 
   @override
-  AnalysisContentStatistics get statistics {
+  AnalysisContextStatistics get statistics {
     bool hintsEnabled = _options.hint;
-    AnalysisContentStatisticsImpl statistics = new AnalysisContentStatisticsImpl();
+    AnalysisContextStatisticsImpl statistics = new AnalysisContextStatisticsImpl();
     MapIterator<Source, SourceEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       SourceEntry sourceEntry = iterator.value;
       if (sourceEntry is DartEntry) {
         Source source = iterator.key;
         DartEntry dartEntry = sourceEntry;
         SourceKind kind = dartEntry.getValue(DartEntry.SOURCE_KIND);
         // get library independent values
         statistics.putCacheItem(dartEntry, SourceEntry.LINE_INFO);
         statistics.putCacheItem(dartEntry, DartEntry.PARSE_ERRORS);
@@ skipping 21 matching lines @@
         }
       } else if (sourceEntry is HtmlEntry) {
         HtmlEntry htmlEntry = sourceEntry;
         statistics.putCacheItem(htmlEntry, SourceEntry.LINE_INFO);
         statistics.putCacheItem(htmlEntry, HtmlEntry.PARSE_ERRORS);
         statistics.putCacheItem(htmlEntry, HtmlEntry.PARSED_UNIT);
         statistics.putCacheItem(htmlEntry, HtmlEntry.RESOLUTION_ERRORS);
         statistics.putCacheItem(htmlEntry, HtmlEntry.RESOLVED_UNIT);
       }
     }
+    statistics.partitionData = _cache.partitionData;
     return statistics;
   }
 
   @override
   TypeProvider get typeProvider {
     Source coreSource = sourceFactory.forUri(DartSdk.DART_CORE);
     if (coreSource == null) {
       throw new AnalysisException.con1("Could not create a source for dart:core");
     }
     LibraryElement coreElement = computeLibraryElement(coreSource);
@@ skipping 244 matching lines @@
       return;
     } else if (factory.context != null) {
       throw new IllegalStateException("Source factories cannot be shared between contexts");
     }
     if (_sourceFactory != null) {
       _sourceFactory.context = null;
     }
     factory.context = this;
     _sourceFactory = factory;
     _coreLibrarySource = _sourceFactory.forUri(DartSdk.DART_CORE);
-    _cache = _createCacheFromSourceFactory(factory);
+    _cache = createCacheFromSourceFactory(factory);
     _invalidateAllLocalResolutionInformation();
   }
 
   /**
+   * Create an analysis cache based on the given source factory.
+   *
+   * @param factory the source factory containing the information needed to create the cache
+   * @return the cache that was created
+   */
+  AnalysisCache createCacheFromSourceFactory(SourceFactory factory) {
+    if (factory == null) {
+      return new AnalysisCache(<CachePartition> [_privatePartition]);
+    }
+    DartSdk sdk = factory.dartSdk;
+    if (sdk == null) {
+      return new AnalysisCache(<CachePartition> [_privatePartition]);
+    }
+    return new AnalysisCache(<CachePartition> [
+        AnalysisEngine.instance.partitionManager.forSdk(sdk),
+        _privatePartition]);
+  }
+
+  /**
    * Record the results produced by performing a [ResolveDartLibraryCycleTask]. 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 recordResolveDartLibraryCycleTaskResults(ResolveDartLibraryCycleTask task) {
     LibraryResolver2 resolver = task.libraryResolver;
     AnalysisException thrownException = task.exception;
     DartEntry unitEntry = null;
     Source unitSource = task.unitSource;
     if (resolver != null) {
       //
       // The resolver should only be null if an exception was thrown before (or while) it was
       // being created.
       //
       List<ResolvableLibrary> resolvedLibraries = resolver.resolvedLibraries;
       if (resolvedLibraries == null) {
         //
         // The resolved libraries should only be null if an exception was thrown during resolution.
         //
         unitEntry = _getReadableDartEntry(unitSource);
         if (unitEntry == null) {
           throw new AnalysisException.con1("A Dart file became a non-Dart file: ${unitSource.fullName}");
         }
         DartEntryImpl dartCopy = unitEntry.writableCopy;
-        dartCopy.recordResolutionError();
-        dartCopy.exception = thrownException;
+        if (thrownException == null) {
+          dartCopy.recordResolutionError(new AnalysisException.con1("In recordResolveDartLibraryCycleTaskResults, resolvedLibraries was null and there was no thrown exception"));
+        } else {
+          dartCopy.recordResolutionError(thrownException);
+        }
         _cache.put(unitSource, dartCopy);
         _cache.remove(unitSource);
         if (thrownException != null) {
           throw thrownException;
         }
         return dartCopy;
       }
       if (_allModificationTimesMatch(resolvedLibraries)) {
         Source htmlSource = sourceFactory.forUri(DartSdk.DART_HTML);
         RecordingErrorListener errorListener = resolver.errorListener;
         for (ResolvableLibrary library in resolvedLibraries) {
           Source librarySource = library.librarySource;
           for (Source source in library.compilationUnitSources) {
             CompilationUnit unit = library.getAST(source);
             List<AnalysisError> errors = errorListener.getErrorsForSource(source);
             LineInfo lineInfo = getLineInfo(source);
             DartEntryImpl dartCopy = _cache.get(source).writableCopy as DartEntryImpl;
             if (thrownException == null) {
               dartCopy.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED);
               dartCopy.setValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource, unit);
               dartCopy.setValueInLibrary(DartEntry.RESOLUTION_ERRORS, librarySource, errors);
               if (source == librarySource) {
                 _recordElementData(dartCopy, library.libraryElement, librarySource, htmlSource);
               }
               _cache.storedAst(source);
             } else {
-              dartCopy.recordResolutionError();
+              dartCopy.recordResolutionErrorInLibrary(librarySource, thrownException);
               _cache.remove(source);
             }
-            dartCopy.exception = thrownException;
             _cache.put(source, dartCopy);
             if (source != librarySource) {
               _workManager.add(source, SourcePriority.PRIORITY_PART);
             }
             if (source == unitSource) {
               unitEntry = dartCopy;
             }
             ChangeNoticeImpl notice = _getNotice(source);
             notice.compilationUnit = unit;
             notice.setErrors(dartCopy.allErrors, lineInfo);
@@ skipping 14 matching lines @@
                 // 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.recordResolutionError(thrownException);
                 _cache.remove(source);
               }
-              dartCopy.exception = thrownException;
               _cache.put(source, dartCopy);
               if (source == unitSource) {
                 unitEntry = dartCopy;
               }
             } else {
               writer.println("  ${_debuggingString(source)}; sourceTime = ${getModificationStamp(source)}, no entry");
             }
           }
         }
         _logInformation(writer.toString());
@@ skipping 24 matching lines @@
       Set<Library> resolvedLibraries = resolver.resolvedLibraries;
       if (resolvedLibraries == null) {
         //
         // The resolved libraries should only be null if an exception was thrown during resolution.
         //
         unitEntry = _getReadableDartEntry(unitSource);
         if (unitEntry == null) {
           throw new AnalysisException.con1("A Dart file became a non-Dart file: ${unitSource.fullName}");
         }
         DartEntryImpl dartCopy = unitEntry.writableCopy;
-        dartCopy.recordResolutionError();
-        dartCopy.exception = thrownException;
+        if (thrownException == null) {
+          dartCopy.recordResolutionError(new AnalysisException.con1("In recordResolveDartLibraryTaskResults, resolvedLibraries was null and there was no thrown exception"));
+        } else {
+          dartCopy.recordResolutionError(thrownException);
+        }
         _cache.put(unitSource, dartCopy);
         _cache.remove(unitSource);
         if (thrownException != null) {
           throw thrownException;
         }
         return dartCopy;
       }
       if (_allModificationTimesMatch2(resolvedLibraries)) {
         Source htmlSource = sourceFactory.forUri(DartSdk.DART_HTML);
         RecordingErrorListener errorListener = resolver.errorListener;
@@ skipping 17 matching lines @@
             if (thrownException == null) {
               dartCopy.setValue(SourceEntry.LINE_INFO, lineInfo);
               dartCopy.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED);
               dartCopy.setValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource, unit);
               dartCopy.setValueInLibrary(DartEntry.RESOLUTION_ERRORS, librarySource, errors);
               if (source == librarySource) {
                 _recordElementData(dartCopy, library.libraryElement, librarySource, htmlSource);
               }
               _cache.storedAst(source);
             } else {
-              dartCopy.recordResolutionError();
+              dartCopy.recordResolutionErrorInLibrary(librarySource, thrownException);
               _cache.remove(source);
             }
-            dartCopy.exception = thrownException;
             _cache.put(source, dartCopy);
             if (source != librarySource) {
               _workManager.add(source, SourcePriority.PRIORITY_PART);
             }
             if (source == unitSource) {
               unitEntry = dartCopy;
             }
             ChangeNoticeImpl notice = _getNotice(source);
             notice.compilationUnit = unit;
             notice.setErrors(dartCopy.allErrors, lineInfo);
@@ skipping 14 matching lines @@
                 // 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.recordResolutionError(thrownException);
                 _cache.remove(source);
               }
-              dartCopy.exception = thrownException;
               _cache.put(source, dartCopy);
               if (source == unitSource) {
                 unitEntry = dartCopy;
               }
             } else {
               writer.println("  ${_debuggingString(source)}; sourceTime = ${getModificationStamp(source)}, no entry");
             }
           }
         }
         _logInformation(writer.toString());
@@ skipping 441 matching lines @@
       AnalysisContextImpl_TaskData taskData = builder.taskData;
       if (taskData != null) {
         return taskData;
       }
       DartEntryImpl dartCopy = dartEntry.writableCopy;
       dartCopy.setStateInLibrary(DartEntry.BUILT_UNIT, source, CacheState.IN_PROCESS);
       _cache.put(source, dartCopy);
       return new AnalysisContextImpl_TaskData(new BuildDartElementModelTask(this, source, builder.librariesInCycle), false);
     } on AnalysisException catch (exception) {
       DartEntryImpl dartCopy = dartEntry.writableCopy;
-      dartCopy.recordBuildElementError();
-      dartCopy.exception = exception;
+      dartCopy.recordBuildElementErrorInLibrary(source, exception);
       _cache.put(source, dartCopy);
       AnalysisEngine.instance.logger.logError2("Internal error trying to compute the next analysis task", exception);
     }
     return new AnalysisContextImpl_TaskData(null, false);
   }
 
   /**
-   * Create an analysis cache based on the given source factory.
-   *
-   * @param factory the source factory containing the information needed to create the cache
-   * @return the cache that was created
-   */
-  AnalysisCache _createCacheFromSourceFactory(SourceFactory factory) {
-    if (factory == null) {
-      return new AnalysisCache(<CachePartition> [_privatePartition]);
-    }
-    DartSdk sdk = factory.dartSdk;
-    if (sdk == null) {
-      return new AnalysisCache(<CachePartition> [_privatePartition]);
-    }
-    return new AnalysisCache(<CachePartition> [
-        AnalysisEngine.instance.partitionManager.forSdk(sdk),
-        _privatePartition]);
-  }
-
-  /**
    * Create a [GenerateDartErrorsTask] for the given source, marking the verification errors
    * as being in-process. The compilation unit and the library can be the same if the compilation
    * unit is the defining compilation unit of the library.
    *
    * @param unitSource the source for the compilation unit to be verified
    * @param unitEntry the entry for the compilation unit
    * @param librarySource the source for the library containing the compilation unit
    * @param libraryEntry the entry for the library
    * @return task data representing the created task
    */
   AnalysisContextImpl_TaskData _createGenerateDartErrorsTask(Source unitSource, DartEntry unitEntry, Source librarySource, DartEntry libraryEntry) {
     if (unitEntry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource) != CacheState.VALID || libraryEntry.getState(DartEntry.ELEMENT) != CacheState.VALID) {
       return _createResolveDartLibraryTask(librarySource, libraryEntry);
     }
     CompilationUnit unit = unitEntry.getValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource);
     if (unit == null) {
-      AnalysisEngine.instance.logger.logInformation2("Entry has VALID state for RESOLVED_UNIT but null value for ${unitSource.fullName} in ${librarySource.fullName}", new AnalysisException());
+      AnalysisException exception = new AnalysisException.con1("Entry has VALID state for RESOLVED_UNIT but null value for ${unitSource.fullName} in ${librarySource.fullName}");
+      AnalysisEngine.instance.logger.logInformation2(exception.toString(), exception);
       DartEntryImpl dartCopy = unitEntry.writableCopy;
-      dartCopy.recordResolutionError();
+      dartCopy.recordResolutionError(exception);
       _cache.put(unitSource, dartCopy);
       return new AnalysisContextImpl_TaskData(null, false);
     }
     LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
     DartEntryImpl dartCopy = unitEntry.writableCopy;
     dartCopy.setStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.IN_PROCESS);
     _cache.put(unitSource, dartCopy);
     return new AnalysisContextImpl_TaskData(new GenerateDartErrorsTask(this, unitSource, dartCopy.modificationTime, unit, libraryElement), false);
   }
 
@@ skipping 174 matching lines @@
     try {
       AnalysisContextImpl_CycleBuilder builder = new AnalysisContextImpl_CycleBuilder(this);
       builder.computeCycleContaining(source);
       AnalysisContextImpl_TaskData taskData = builder.taskData;
       if (taskData != null) {
         return taskData;
       }
       return new AnalysisContextImpl_TaskData(new ResolveDartLibraryCycleTask(this, source, source, builder.librariesInCycle), false);
     } on AnalysisException catch (exception) {
       DartEntryImpl dartCopy = dartEntry.writableCopy;
-      dartCopy.recordResolutionError();
-      dartCopy.exception = exception;
+      dartCopy.recordResolutionError(exception);
       _cache.put(source, dartCopy);
-      AnalysisEngine.instance.logger.logError2("Internal error trying to compute the next analysis task", exception);
+      AnalysisEngine.instance.logger.logError2("Internal error trying to create a ResolveDartLibraryTask", exception);
     }
     return new AnalysisContextImpl_TaskData(null, false);
   }
 
   /**
    * Create a [ResolveHtmlTask] for the given source, marking the resolved unit as being
    * in-process.
    *
    * @param source the source whose content is to be resolved
    * @param htmlEntry the entry for the source
@@ skipping 1068 matching lines @@
           if (thrownException == null) {
             dartCopy.setValueInLibrary(DartEntry.BUILD_ELEMENT_ERRORS, librarySource, errors);
             dartCopy.setValueInLibrary(DartEntry.BUILT_UNIT, librarySource, unit);
             if (source == librarySource) {
               LibraryElementImpl libraryElement = library.libraryElement;
               dartCopy.setValue(DartEntry.ELEMENT, libraryElement);
               dartCopy.setValue(DartEntry.IS_LAUNCHABLE, libraryElement.entryPoint != null);
               dartCopy.setValue(DartEntry.IS_CLIENT, _isClient(libraryElement, htmlSource, new Set<LibraryElement>()));
             }
           } else {
-            dartCopy.recordBuildElementError();
+            dartCopy.recordBuildElementErrorInLibrary(librarySource, thrownException);
             _cache.remove(source);
           }
-          dartCopy.exception = thrownException;
           _cache.put(source, dartCopy);
           if (source != librarySource) {
             _workManager.add(librarySource, SourcePriority.PRIORITY_PART);
           }
           if (source == targetLibrary) {
             targetEntry = dartCopy;
           }
           ChangeNoticeImpl notice = _getNotice(source);
           notice.compilationUnit = unit;
           notice.setErrors(dartCopy.allErrors, lineInfo);
         }
       }
     } else {
       PrintStringWriter writer = new PrintStringWriter();
       writer.println("Build element model results discarded for");
       for (ResolvableLibrary library in builtLibraries) {
+        Source librarySource = library.librarySource;
         for (Source source in library.compilationUnitSources) {
           DartEntry dartEntry = _getReadableDartEntry(source);
           if (dartEntry != null) {
             int resultTime = library.getModificationTime(source);
             writer.println("  ${_debuggingString(source)}; sourceTime = ${getModificationStamp(source)}, 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.recordBuildElementNotInProcess();
             } 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.recordBuildElementError();
+              dartCopy.recordBuildElementErrorInLibrary(librarySource, thrownException);
               _cache.remove(source);
             }
-            dartCopy.exception = thrownException;
             _cache.put(source, dartCopy);
             if (source == targetLibrary) {
               targetEntry = dartCopy;
             }
           } else {
             writer.println("  ${_debuggingString(source)}; sourceTime = ${getModificationStamp(source)}, no entry");
           }
         }
       }
       _logInformation(writer.toString());
@@ skipping 57 matching lines @@
         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.setValueInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource, task.errors);
         ChangeNoticeImpl notice = _getNotice(source);
         notice.setErrors(dartCopy.allErrors, dartCopy.getValue(SourceEntry.LINE_INFO));
       } else {
-        dartCopy.setStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.ERROR);
+        dartCopy.recordVerificationErrorInLibrary(librarySource, thrownException);
       }
-      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.setState(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.INVALID);
         _removeFromParts(source, dartEntry);
         dartCopy.invalidateAllInformation();
         dartCopy.modificationTime = sourceTime;
         _cache.removedAst(source);
         _workManager.add(source, SourcePriority.UNKNOWN);
       } 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-verify the source until there's a good chance
         // that we'll be able to do so without error.
         //
-        dartCopy.setStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.ERROR);
+        dartCopy.recordVerificationErrorInLibrary(librarySource, thrownException);
       }
-      dartCopy.exception = thrownException;
       _cache.put(source, dartCopy);
       dartEntry = dartCopy;
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return dartEntry;
   }
 
   /**
@@ skipping 17 matching lines @@
         throw new ObsoleteSourceAnalysisException(librarySource);
       } else if (sourceEntry is! DartEntry) {
         // This shouldn't be possible because we should never have performed the task if the source
         // didn't represent a Dart file, but check to be safe.
         throw new AnalysisException.con1("Internal error: attempting to generate hints for non-Dart file as a Dart file: ${librarySource.fullName}");
       }
       if (thrownException == null) {
         thrownException = new AnalysisException.con1("GenerateDartHintsTask returned a null hint map without throwing an exception: ${librarySource.fullName}");
       }
       DartEntryImpl dartCopy = (sourceEntry as DartEntry).writableCopy;
-      dartCopy.setStateInLibrary(DartEntry.HINTS, librarySource, CacheState.ERROR);
-      dartCopy.exception = thrownException;
+      dartCopy.recordHintErrorInLibrary(librarySource, thrownException);
       _cache.put(librarySource, dartCopy);
       throw thrownException;
     }
     for (MapEntry<Source, TimestampedData<List<AnalysisError>>> entry in getMapEntrySet(hintMap)) {
       Source unitSource = entry.getKey();
       TimestampedData<List<AnalysisError>> results = entry.getValue();
       SourceEntry sourceEntry = _cache.get(unitSource);
       if (sourceEntry is! DartEntry) {
         // This shouldn't be possible because we should never have performed the task if the source
         // didn't represent a Dart file, but check to be safe.
@@ skipping 13 matching lines @@
           if (dartEntry == null) {
             throw new AnalysisException.con1("A Dart file became a non-Dart file: ${unitSource.fullName}");
           }
         }
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         if (thrownException == null) {
           dartCopy.setValueInLibrary(DartEntry.HINTS, librarySource, results.data);
           ChangeNoticeImpl notice = _getNotice(unitSource);
           notice.setErrors(dartCopy.allErrors, dartCopy.getValue(SourceEntry.LINE_INFO));
         } else {
-          dartCopy.setStateInLibrary(DartEntry.HINTS, librarySource, CacheState.ERROR);
+          dartCopy.recordHintErrorInLibrary(librarySource, thrownException);
         }
-        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 (dartEntry.getStateInLibrary(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.setState(DartEntry.HINTS, librarySource, CacheState.INVALID);
             _removeFromParts(unitSource, dartEntry);
             dartCopy.invalidateAllInformation();
             dartCopy.modificationTime = sourceTime;
             _cache.removedAst(unitSource);
             _workManager.add(unitSource, SourcePriority.UNKNOWN);
           } 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.setStateInLibrary(DartEntry.HINTS, librarySource, CacheState.ERROR);
+            dartCopy.recordHintErrorInLibrary(librarySource, thrownException);
           }
-          dartCopy.exception = thrownException;
           _cache.put(unitSource, dartCopy);
           dartEntry = dartCopy;
         }
       }
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return libraryEntry;
   }
@@ skipping 14 matching lines @@
     SourceEntry sourceEntry = null;
     sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       throw new ObsoleteSourceAnalysisException(source);
     }
     SourceEntryImpl sourceCopy = sourceEntry.writableCopy;
     if (thrownException == null) {
       sourceCopy.modificationTime = task.modificationTime;
       sourceCopy.setValue(SourceEntry.CONTENT, task.content);
     } else {
-      sourceCopy.exception = thrownException;
-      sourceCopy.recordContentError();
+      sourceCopy.recordContentError(thrownException);
       _workManager.remove(source);
     }
     _cache.put(source, sourceCopy);
     sourceEntry = sourceCopy;
     if (thrownException != null) {
       throw thrownException;
     }
     return sourceEntry;
   }
 
@@ skipping 88 matching lines @@
         dartCopy.setValue(DartEntry.IMPORTED_LIBRARIES, task.importedSources);
         dartCopy.setValue(DartEntry.INCLUDED_PARTS, newParts);
         _cache.storedAst(source);
         ChangeNoticeImpl notice = _getNotice(source);
         notice.setErrors(dartCopy.allErrors, task.lineInfo);
         // 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 {
         _removeFromParts(source, dartEntry);
-        dartCopy.recordParseError();
+        dartCopy.recordParseError(thrownException);
         _cache.removedAst(source);
       }
-      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();
         _removeFromParts(source, dartEntry);
         dartCopy.invalidateAllInformation();
         dartCopy.modificationTime = sourceTime;
         _cache.removedAst(source);
         _workManager.add(source, SourcePriority.UNKNOWN);
       } 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.recordParseError();
+        dartCopy.recordParseError(thrownException);
       }
-      dartCopy.exception = thrownException;
       _cache.put(source, dartCopy);
       dartEntry = dartCopy;
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return dartEntry;
   }
 
   /**
@@ skipping 33 matching lines @@
         LineInfo lineInfo = task.lineInfo;
         ht.HtmlUnit unit = task.htmlUnit;
         htmlCopy.setValue(SourceEntry.LINE_INFO, lineInfo);
         htmlCopy.setValue(HtmlEntry.PARSED_UNIT, unit);
         htmlCopy.setValue(HtmlEntry.PARSE_ERRORS, task.errors);
         htmlCopy.setValue(HtmlEntry.REFERENCED_LIBRARIES, task.referencedLibraries);
         _cache.storedAst(source);
         ChangeNoticeImpl notice = _getNotice(source);
         notice.setErrors(htmlCopy.allErrors, lineInfo);
       } else {
-        htmlCopy.recordParseError();
+        htmlCopy.recordParseError(thrownException);
         _cache.removedAst(source);
       }
-      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 (htmlCopy.getState(SourceEntry.LINE_INFO) == CacheState.IN_PROCESS) {
         //            htmlCopy.setState(SourceEntry.LINE_INFO, CacheState.INVALID);
         //          }
         //          if (htmlCopy.getState(HtmlEntry.PARSED_UNIT) == CacheState.IN_PROCESS) {
         //            htmlCopy.setState(HtmlEntry.PARSED_UNIT, CacheState.INVALID);
         //          }
         //          if (htmlCopy.getState(HtmlEntry.REFERENCED_LIBRARIES) == CacheState.IN_PROCESS) {
         //            htmlCopy.setState(HtmlEntry.REFERENCED_LIBRARIES, CacheState.INVALID);
         //          }
         htmlCopy.invalidateAllInformation();
         htmlCopy.modificationTime = sourceTime;
         _cache.removedAst(source);
       } 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.
         //
-        htmlCopy.setState(SourceEntry.LINE_INFO, CacheState.ERROR);
-        htmlCopy.setState(HtmlEntry.PARSED_UNIT, CacheState.ERROR);
-        htmlCopy.setState(HtmlEntry.RESOLVED_UNIT, CacheState.ERROR);
-        htmlCopy.setState(HtmlEntry.REFERENCED_LIBRARIES, CacheState.ERROR);
+        htmlCopy.recordParseError(thrownException);
       }
-      htmlCopy.exception = thrownException;
       _cache.put(source, htmlCopy);
       htmlEntry = htmlCopy;
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return htmlEntry;
   }
 
   /**
@@ skipping 27 matching lines @@
           throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
         }
       }
       HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
       if (thrownException == null) {
         htmlCopy.setValue(HtmlEntry.POLYMER_BUILD_ERRORS, task.errors);
         // notify about errors
         ChangeNoticeImpl notice = _getNotice(source);
         notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
       } else {
-        htmlCopy.recordResolutionError();
+        htmlCopy.recordResolutionError(thrownException);
       }
-      htmlCopy.exception = thrownException;
       _cache.put(source, htmlCopy);
       htmlEntry = htmlCopy;
     } else {
       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.
         //
         htmlCopy.invalidateAllInformation();
         htmlCopy.modificationTime = sourceTime;
         _cache.removedAst(source);
       } 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.
         //
-        htmlCopy.recordResolutionError();
+        htmlCopy.recordResolutionError(thrownException);
       }
-      htmlCopy.exception = thrownException;
       _cache.put(source, htmlCopy);
       htmlEntry = htmlCopy;
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return htmlEntry;
   }
 
   /**
@@ skipping 27 matching lines @@
           throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
         }
       }
       HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
       if (thrownException == null) {
         htmlCopy.setValue(HtmlEntry.POLYMER_RESOLUTION_ERRORS, task.errors);
         // notify about errors
         ChangeNoticeImpl notice = _getNotice(source);
         notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
       } else {
-        htmlCopy.recordResolutionError();
+        htmlCopy.recordResolutionError(thrownException);
       }
-      htmlCopy.exception = thrownException;
       _cache.put(source, htmlCopy);
       htmlEntry = htmlCopy;
     } else {
       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.
         //
         htmlCopy.invalidateAllInformation();
         htmlCopy.modificationTime = sourceTime;
         _cache.removedAst(source);
       } 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.
         //
-        htmlCopy.recordResolutionError();
+        htmlCopy.recordResolutionError(thrownException);
       }
-      htmlCopy.exception = thrownException;
       _cache.put(source, htmlCopy);
       htmlEntry = htmlCopy;
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return htmlEntry;
   }
 
   /**
@@ skipping 28 matching lines @@
         }
       }
       HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
       if (thrownException == null) {
         htmlCopy.setValue(HtmlEntry.ANGULAR_ERRORS, task.resolutionErrors);
         // notify about errors
         ChangeNoticeImpl notice = _getNotice(source);
         notice.htmlUnit = task.resolvedUnit;
         notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
       } else {
-        htmlCopy.recordResolutionError();
+        htmlCopy.recordResolutionError(thrownException);
       }
-      htmlCopy.exception = thrownException;
       _cache.put(source, htmlCopy);
       htmlEntry = htmlCopy;
     } else {
       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 (htmlCopy.getState(HtmlEntry.ANGULAR_ERRORS) == CacheState.IN_PROCESS) {
         //            htmlCopy.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.INVALID);
         //          }
         //          if (htmlCopy.getState(HtmlEntry.ELEMENT) == CacheState.IN_PROCESS) {
         //            htmlCopy.setState(HtmlEntry.ELEMENT, CacheState.INVALID);
         //          }
         //          if (htmlCopy.getState(HtmlEntry.RESOLUTION_ERRORS) == CacheState.IN_PROCESS) {
         //            htmlCopy.setState(HtmlEntry.RESOLUTION_ERRORS, CacheState.INVALID);
         //          }
         htmlCopy.invalidateAllInformation();
         htmlCopy.modificationTime = sourceTime;
         _cache.removedAst(source);
       } 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.
         //
-        htmlCopy.recordResolutionError();
+        htmlCopy.recordResolutionError(thrownException);
       }
-      htmlCopy.exception = thrownException;
       _cache.put(source, htmlCopy);
       htmlEntry = htmlCopy;
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return htmlEntry;
   }
 
   /**
@@ skipping 29 matching lines @@
       }
       HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
       if (thrownException == null) {
         htmlCopy.setValue(HtmlEntry.RESOLVED_UNIT, task.resolvedUnit);
         _recordAngularEntryPoint(htmlCopy, task);
         _cache.storedAst(source);
         ChangeNoticeImpl notice = _getNotice(source);
         notice.htmlUnit = task.resolvedUnit;
         notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
       } else {
-        htmlCopy.recordResolutionError();
+        htmlCopy.recordResolutionError(thrownException);
       }
-      htmlCopy.exception = thrownException;
       _cache.put(source, htmlCopy);
       htmlEntry = htmlCopy;
     } else {
       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 (htmlCopy.getState(HtmlEntry.ANGULAR_ERRORS) == CacheState.IN_PROCESS) {
         //            htmlCopy.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.INVALID);
         //          }
         //          if (htmlCopy.getState(HtmlEntry.ELEMENT) == CacheState.IN_PROCESS) {
         //            htmlCopy.setState(HtmlEntry.ELEMENT, CacheState.INVALID);
         //          }
         //          if (htmlCopy.getState(HtmlEntry.RESOLUTION_ERRORS) == CacheState.IN_PROCESS) {
         //            htmlCopy.setState(HtmlEntry.RESOLUTION_ERRORS, CacheState.INVALID);
         //          }
         htmlCopy.invalidateAllInformation();
         htmlCopy.modificationTime = sourceTime;
         _cache.removedAst(source);
       } 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.
         //
-        htmlCopy.recordResolutionError();
+        htmlCopy.recordResolutionError(thrownException);
       }
-      htmlCopy.exception = thrownException;
       _cache.put(source, htmlCopy);
       htmlEntry = htmlCopy;
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return htmlEntry;
   }
 
   /**
@@ skipping 27 matching lines @@
         dartEntry = _getReadableDartEntry(unitSource);
         if (dartEntry == null) {
           throw new AnalysisException.con1("A Dart file became a non-Dart file: ${unitSource.fullName}");
         }
       }
       DartEntryImpl dartCopy = dartEntry.writableCopy;
       if (thrownException == null) {
         dartCopy.setValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource, task.resolvedUnit);
         _cache.storedAst(unitSource);
       } else {
-        dartCopy.setStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource, CacheState.ERROR);
+        dartCopy.recordResolutionErrorInLibrary(librarySource, thrownException);
         _cache.removedAst(unitSource);
       }
-      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 (dartCopy.getState(DartEntry.RESOLVED_UNIT) == CacheState.IN_PROCESS) {
         //            dartCopy.setState(DartEntry.RESOLVED_UNIT, librarySource, CacheState.INVALID);
         //          }
         _removeFromParts(unitSource, dartEntry);
         dartCopy.invalidateAllInformation();
         dartCopy.modificationTime = sourceTime;
         _cache.removedAst(unitSource);
         _workManager.add(unitSource, SourcePriority.UNKNOWN);
       } 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.setStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource, CacheState.ERROR);
+        dartCopy.recordResolutionErrorInLibrary(librarySource, thrownException);
       }
-      dartCopy.exception = thrownException;
       _cache.put(unitSource, dartCopy);
       dartEntry = dartCopy;
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return dartEntry;
   }
 
   /**
@@ skipping 32 matching lines @@
       if (thrownException == null) {
         htmlCopy.setState(HtmlEntry.PARSED_UNIT, CacheState.FLUSHED);
         htmlCopy.setValue(HtmlEntry.RESOLVED_UNIT, task.resolvedUnit);
         htmlCopy.setValue(HtmlEntry.ELEMENT, task.element);
         htmlCopy.setValue(HtmlEntry.RESOLUTION_ERRORS, task.resolutionErrors);
         _cache.storedAst(source);
         ChangeNoticeImpl notice = _getNotice(source);
         notice.htmlUnit = task.resolvedUnit;
         notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
       } else {
-        htmlCopy.recordResolutionError();
+        htmlCopy.recordResolutionError(thrownException);
         _cache.removedAst(source);
       }
-      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 (htmlCopy.getState(HtmlEntry.ELEMENT) == CacheState.IN_PROCESS) {
         //            htmlCopy.setState(HtmlEntry.ELEMENT, CacheState.INVALID);
         //          }
         //          if (htmlCopy.getState(HtmlEntry.RESOLUTION_ERRORS) == CacheState.IN_PROCESS) {
         //            htmlCopy.setState(HtmlEntry.RESOLUTION_ERRORS, CacheState.INVALID);
         //          }
         htmlCopy.invalidateAllInformation();
         htmlCopy.modificationTime = sourceTime;
         _cache.removedAst(source);
       } 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.
         //
-        htmlCopy.recordResolutionError();
+        htmlCopy.recordResolutionError(thrownException);
       }
-      htmlCopy.exception = thrownException;
       _cache.put(source, htmlCopy);
       htmlEntry = htmlCopy;
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return htmlEntry;
   }
 
   /**
@@ skipping 33 matching lines @@
         LineInfo lineInfo = task.lineInfo;
         dartCopy.setValue(SourceEntry.LINE_INFO, lineInfo);
         dartCopy.setValue(DartEntry.TOKEN_STREAM, task.tokenStream);
         dartCopy.setValue(DartEntry.SCAN_ERRORS, task.errors);
         _cache.storedAst(source);
         _workManager.add(source, SourcePriority.NORMAL_PART);
         ChangeNoticeImpl notice = _getNotice(source);
         notice.setErrors(dartEntry.allErrors, lineInfo);
       } else {
         _removeFromParts(source, dartEntry);
-        dartCopy.recordScanError();
+        dartCopy.recordScanError(thrownException);
         _cache.removedAst(source);
       }
-      dartCopy.exception = thrownException;
       _cache.put(source, dartCopy);
       dartEntry = dartCopy;
     } else {
       _logInformation2("Scan 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.recordScanNotInProcess();
         _removeFromParts(source, dartEntry);
         dartCopy.invalidateAllInformation();
         dartCopy.modificationTime = sourceTime;
         _cache.removedAst(source);
         _workManager.add(source, SourcePriority.UNKNOWN);
       } 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.recordScanError();
+        dartCopy.recordScanError(thrownException);
       }
-      dartCopy.exception = thrownException;
       _cache.put(source, dartCopy);
       dartEntry = dartCopy;
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return dartEntry;
   }
 
   /**
@@ skipping 142 matching lines @@
   /**
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source that has been deleted
    */
   void _sourceDeleted(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry is HtmlEntry) {
       HtmlEntryImpl htmlCopy = sourceEntry.writableCopy;
       _invalidateAngularResolution(htmlCopy);
-      htmlCopy.recordContentError();
+      htmlCopy.recordContentError(new AnalysisException.con1("This source was marked as being deleted"));
       _cache.put(source, htmlCopy);
     } else 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);
       }
       DartEntryImpl dartCopy = sourceEntry.writableCopy;
-      dartCopy.recordContentError();
+      dartCopy.recordContentError(new AnalysisException.con1("This source was marked as being deleted"));
       _cache.put(source, dartCopy);
     }
     _workManager.remove(source);
     _removeFromPriorityOrder(source);
   }
 
   /**
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source that has been removed
@@ skipping 656 matching lines @@
 
   @override
   String toString() {
     if (task == null) {
       return "blocked: ${_blocked}";
     }
     return task.toString();
   }
 }
 
+/**
+ * The interface `AnalysisContextStatistics` defines access to statistics about a single
+ * [AnalysisContext].
+ */
+abstract class AnalysisContextStatistics {
+  /**
+   * Return the statistics for each kind of cached data.
+   */
+  List<AnalysisContextStatistics_CacheRow> get cacheRows;
+
+  /**
+   * Return the exceptions that caused some entries to have a state of [CacheState#ERROR].
+   */
+  List<AnalysisException> get exceptions;
+
+  /**
+   * Return information about each of the partitions in the cache.
+   */
+  List<AnalysisContextStatistics_PartitionData> get partitionData;
+
+  /**
+   * Return an array containing all of the sources in the cache.
+   */
+  List<Source> get sources;
+}
+
+/**
+ * Implementation of the [AnalysisContextStatistics].
+ */
+class AnalysisContextStatisticsImpl implements AnalysisContextStatistics {
+  Map<String, AnalysisContextStatistics_CacheRow> _dataMap = new Map<String, AnalysisContextStatistics_CacheRow>();
+
+  List<Source> _sources = new List<Source>();
+
+  Set<AnalysisException> _exceptions = new Set<AnalysisException>();
+
+  List<AnalysisContextStatistics_PartitionData> _partitionData;
+
+  void addSource(Source source) {
+    _sources.add(source);
+  }
+
+  @override
+  List<AnalysisContextStatistics_CacheRow> get cacheRows {
+    Iterable<AnalysisContextStatistics_CacheRow> items = _dataMap.values;
+    return new List.from(items);
+  }
+
+  @override
+  List<AnalysisException> get exceptions => new List.from(_exceptions);
+
+  @override
+  List<AnalysisContextStatistics_PartitionData> get partitionData => _partitionData;
+
+  @override
+  List<Source> get sources => new List.from(_sources);
+
+  void putCacheItem(SourceEntry dartEntry, DataDescriptor descriptor) {
+    _internalPutCacheItem(dartEntry, descriptor, dartEntry.getState(descriptor));
+  }
+
+  void putCacheItemInLibrary(DartEntry dartEntry, Source librarySource, DataDescriptor descriptor) {
+    _internalPutCacheItem(dartEntry, descriptor, dartEntry.getStateInLibrary(descriptor, librarySource));
+  }
+
+  /**
+   * Set the partition data returned by this object to the given data.
+   */
+  void set partitionData(List<AnalysisContextStatistics_PartitionData> data) {
+    _partitionData = data;
+  }
+
+  void _internalPutCacheItem(SourceEntry dartEntry, DataDescriptor rowDesc, CacheState state) {
+    String rowName = rowDesc.toString();
+    AnalysisContextStatisticsImpl_CacheRowImpl row = _dataMap[rowName] as AnalysisContextStatisticsImpl_CacheRowImpl;
+    if (row == null) {
+      row = new AnalysisContextStatisticsImpl_CacheRowImpl(rowName);
+      _dataMap[rowName] = row;
+    }
+    row._incState(state);
+    if (state == CacheState.ERROR) {
+      AnalysisException exception = dartEntry.exception;
+      if (exception != null) {
+        _exceptions.add(exception);
+      }
+    }
+  }
+}
+
+class AnalysisContextStatisticsImpl_CacheRowImpl implements AnalysisContextStatistics_CacheRow {
+  final String name;
+
+  int _errorCount = 0;
+
+  int _flushedCount = 0;
+
+  int _inProcessCount = 0;
+
+  int _invalidCount = 0;
+
+  int _validCount = 0;
+
+  AnalysisContextStatisticsImpl_CacheRowImpl(this.name);
+
+  @override
+  bool operator ==(Object obj) => obj is AnalysisContextStatisticsImpl_CacheRowImpl && obj.name == name;
+
+  @override
+  int get errorCount => _errorCount;
+
+  @override
+  int get flushedCount => _flushedCount;
+
+  @override
+  int get inProcessCount => _inProcessCount;
+
+  @override
+  int get invalidCount => _invalidCount;
+
+  @override
+  int get validCount => _validCount;
+
+  @override
+  int get hashCode => name.hashCode;
+
+  void _incState(CacheState state) {
+    if (state == CacheState.ERROR) {
+      _errorCount++;
+    }
+    if (state == CacheState.FLUSHED) {
+      _flushedCount++;
+    }
+    if (state == CacheState.IN_PROCESS) {
+      _inProcessCount++;
+    }
+    if (state == CacheState.INVALID) {
+      _invalidCount++;
+    }
+    if (state == CacheState.VALID) {
+      _validCount++;
+    }
+  }
+}
+
+class AnalysisContextStatisticsImpl_PartitionDataImpl implements AnalysisContextStatistics_PartitionData {
+  final int astCount;
+
+  final int totalCount;
+
+  AnalysisContextStatisticsImpl_PartitionDataImpl(this.astCount, this.totalCount);
+}
+
+/**
+ * Information about single piece of data in the cache.
+ */
+abstract class AnalysisContextStatistics_CacheRow {
+  /**
+   * Return the number of entries whose state is [CacheState#ERROR].
+   */
+  int get errorCount;
+
+  /**
+   * Return the number of entries whose state is [CacheState#FLUSHED].
+   */
+  int get flushedCount;
+
+  /**
+   * Return the number of entries whose state is [CacheState#IN_PROCESS].
+   */
+  int get inProcessCount;
+
+  /**
+   * Return the number of entries whose state is [CacheState#INVALID].
+   */
+  int get invalidCount;
+
+  /**
+   * Return the name of the data represented by this object.
+   */
+  String get name;
+
+  /**
+   * Return the number of entries whose state is [CacheState#VALID].
+   */
+  int get validCount;
+}
+
+/**
+ * Information about a single partition in the cache.
+ */
+abstract class AnalysisContextStatistics_PartitionData {
+  /**
+   * Return the number of entries in the partition that have an AST structure in one state or
+   * another.
+   */
+  int get astCount;
+
+  /**
+   * Return the total number of entries in the partition.
+   */
+  int get totalCount;
+}
+
+/**
+ * Instances of the class `AnalysisDelta` indicate changes to the types of analysis that
+ * should be performed.
+ */
+class AnalysisDelta {
+  /**
+   * A mapping from source to what type of analysis should be performed on that source.
+   */
+  Map<Source, AnalysisLevel> _analysisMap = new Map<Source, AnalysisLevel>();
+
+  /**
+   * Return a collection of the sources that have been added. This is equivalent to calling
+   * [getAnalysisLevels] and collecting all sources that do not have an analysis level of
+   * [AnalysisLevel#NONE].
+   *
+   * @return a collection of the sources
+   */
+  Iterable<Source> get addedSources {
+    List<Source> result = new List<Source>();
+    for (MapEntry<Source, AnalysisLevel> entry in getMapEntrySet(_analysisMap)) {
+      if (entry.getValue() != AnalysisLevel.NONE) {
+        result.add(entry.getKey());
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Return a mapping of sources to the level of analysis that should be performed.
+   *
+   * @return the analysis map
+   */
+  Map<Source, AnalysisLevel> get analysisLevels => _analysisMap;
+
+  /**
+   * Record that the specified source should be analyzed at the specified level.
+   *
+   * @param source the source
+   * @param level the level at which the given source should be analyzed
+   */
+  void setAnalysisLevel(Source source, AnalysisLevel level) {
+    _analysisMap[source] = level;
+  }
+
+  @override
+  String toString() {
+    JavaStringBuilder builder = new JavaStringBuilder();
+    bool needsSeparator = _appendSources(builder, false, AnalysisLevel.ALL);
+    needsSeparator = _appendSources(builder, needsSeparator, AnalysisLevel.RESOLVED);
+    _appendSources(builder, needsSeparator, AnalysisLevel.NONE);
+    return builder.toString();
+  }
+
+  /**
+   * Append sources with the given analysis level, prefixed with a label and possibly a separator.
+   *
+   * @param builder the builder to which the sources are to be appended
+   * @param needsSeparator `true` if a separator is needed before the label
+   * @param level the analysis level of the sources to be appended
+   * @return `true` if future lists of sources will need a separator
+   */
+  bool _appendSources(JavaStringBuilder builder, bool needsSeparator, AnalysisLevel level) {
+    bool first = true;
+    for (MapEntry<Source, AnalysisLevel> entry in getMapEntrySet(_analysisMap)) {
+      if (entry.getValue() == level) {
+        if (first) {
+          first = false;
+          if (needsSeparator) {
+            builder.append("; ");
+          }
+          builder.append(level);
+          builder.append(" ");
+        } else {
+          builder.append(", ");
+        }
+        builder.append(entry.getKey().fullName);
+      }
+    }
+    return needsSeparator || !first;
+  }
+}
+
 /**
  * The unique instance of the class `AnalysisEngine` serves as the entry point for the
  * functionality provided by the analysis engine.
  */
 class AnalysisEngine {
   /**
    * The suffix used for Dart source files.
    */
   static String SUFFIX_DART = "dart";
 
@@ skipping 162 matching lines @@
 
   /**
    * Initialize a newly created exception to have the given cause.
    *
    * @param cause the underlying exception that caused this exception
    */
   AnalysisException.con3(Exception cause) : super.withCause(cause);
 }
 
 /**
+ * The enumeration `AnalysisLevel` encodes the different levels at which a source can be
+ * analyzed.
+ */
+class AnalysisLevel extends Enum<AnalysisLevel> {
+  /**
+   * Indicates a source should be fully analyzed.
+   */
+  static const AnalysisLevel ALL = const AnalysisLevel('ALL', 0);
+
+  /**
+   * Indicates a source should be resolved and that errors, warnings and hints are needed.
+   */
+  static const AnalysisLevel ERRORS = const AnalysisLevel('ERRORS', 1);
+
+  /**
+   * Indicates a source should be resolved, but that errors, warnings and hints are not needed.
+   */
+  static const AnalysisLevel RESOLVED = const AnalysisLevel('RESOLVED', 2);
+
+  /**
+   * Indicates a source is not of interest to the client.
+   */
+  static const AnalysisLevel NONE = const AnalysisLevel('NONE', 3);
+
+  static const List<AnalysisLevel> values = const [ALL, ERRORS, RESOLVED, NONE];
+
+  const AnalysisLevel(String name, int ordinal) : super(name, ordinal);
+}
+
+/**
  * The interface `AnalysisOptions` defines the behavior of objects that provide access to a
  * set of analysis options used to control the behavior of an analysis context.
  */
 abstract class AnalysisOptions {
   /**
    * Return `true` if analysis is to analyze Angular.
    *
    * @return `true` if analysis is to analyze Angular
    */
   bool get analyzeAngular;
@@ skipping 1743 matching lines @@
 
   /**
    * Return the entry associated with the given source.
    *
    * @param source the source whose entry is to be returned
    * @return the entry associated with the given source
    */
   SourceEntry get(Source source) => _sourceMap[source];
 
   /**
+   * Return the number of entries in this partition that have an AST associated with them.
+   *
+   * @return the number of entries in this partition that have an AST associated with them
+   */
+  int get astSize {
+    int astSize = 0;
+    int count = _recentlyUsed.length;
+    for (int i = 0; i < count; i++) {
+      Source source = _recentlyUsed[i];
+      SourceEntry sourceEntry = _sourceMap[source];
+      if (sourceEntry is DartEntry) {
+        if (sourceEntry.anyParsedCompilationUnit != null) {
+          astSize++;
+        }
+      } else if (sourceEntry is HtmlEntry) {
+        if (sourceEntry.anyParsedUnit != null) {
+          astSize++;
+        }
+      }
+    }
+    return astSize;
+  }
+
+  /**
    * Return a table mapping the sources known to the context to the information known about the
    * source.
    *
    * <b>Note:</b> This method is only visible for use by [AnalysisCache] and should not be
    * used for any other purpose.
    *
    * @return a table mapping the sources known to the context to the information known about the
    *         source
    */
   Map<Source, SourceEntry> get map => _sourceMap;
@@ skipping 1127 matching lines @@
           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.BUILD_ELEMENT_ERRORS) || identical(descriptor, DartEntry.RESOLUTION_ERRORS) || identical(descriptor, DartEntry.RESOLVED_UNIT) || identical(descriptor, DartEntry.VERIFICATION_ERRORS) || identical(descriptor, DartEntry.HINTS)) {
+    if (identical(descriptor, DartEntry.BUILD_ELEMENT_ERRORS) || identical(descriptor, DartEntry.BUILT_UNIT) || 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}");
     }
   }
 
   @override
   Object getValue(DataDescriptor descriptor) {
     if (identical(descriptor, DartEntry.ANGULAR_ERRORS)) {
       return _angularErrors;
@@ skipping 190 matching lines @@
       }
       state = state._nextState;
     }
     return true;
   }
 
   /**
    * Record that an error occurred while attempting to build the element model for the source
    * 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.
+   *
+   * @param librarySource the source of the library in which the element model was being built
+   * @param exception the exception that shows where the error occurred
    */
-  void recordBuildElementError() {
+  void recordBuildElementErrorInLibrary(Source librarySource, AnalysisException exception) {
+    this.exception = exception;
     _element = null;
     _elementState = CacheState.ERROR;
     clearFlags([_LAUNCHABLE_INDEX, _CLIENT_CODE_INDEX]);
     _clientServerState = CacheState.ERROR;
     _launchableState = CacheState.ERROR;
-    recordResolutionError();
+    DartEntryImpl_ResolutionState state = _getOrCreateResolutionState(librarySource);
+    state.recordBuildElementError();
   }
 
   /**
    * Record that an in-process model build has stopped without recording results because the results
    * were invalidated before they could be recorded.
    */
   void recordBuildElementNotInProcess() {
     if (_elementState == CacheState.IN_PROCESS) {
       _elementState = CacheState.INVALID;
     }
     if (_clientServerState == CacheState.IN_PROCESS) {
       _clientServerState = CacheState.INVALID;
     }
     if (_launchableState == CacheState.IN_PROCESS) {
       _launchableState = CacheState.INVALID;
     }
   }
 
   @override
-  void recordContentError() {
-    super.recordContentError();
-    recordScanError();
+  void recordContentError(AnalysisException exception) {
+    super.recordContentError(exception);
+    recordScanError(exception);
+  }
+
+  /**
+   * Record that an error occurred while attempting to generate hints for the source represented by
+   * this entry. This will set the state of all verification information as being in error.
+   *
+   * @param librarySource the source of the library in which hints were being generated
+   * @param exception the exception that shows where the error occurred
+   */
+  void recordHintErrorInLibrary(Source librarySource, AnalysisException exception) {
+    this.exception = exception;
+    DartEntryImpl_ResolutionState state = _getOrCreateResolutionState(librarySource);
+    state.recordHintError();
   }
 
   /**
    * Record that an error occurred while attempting to scan or parse the entry represented by this
    * entry. This will set the state of all information, including any resolution-based information,
    * as being in error.
+   *
+   * @param exception the exception that shows where the error occurred
    */
-  void recordParseError() {
+  void recordParseError(AnalysisException exception) {
     _sourceKind = SourceKind.UNKNOWN;
     _sourceKindState = CacheState.ERROR;
     _parseErrors = AnalysisError.NO_ERRORS;
     _parseErrorsState = CacheState.ERROR;
     _parsedUnit = null;
     _parsedUnitAccessed = false;
     _parsedUnitState = CacheState.ERROR;
     _exportedLibraries = Source.EMPTY_ARRAY;
     _exportedLibrariesState = CacheState.ERROR;
     _importedLibraries = Source.EMPTY_ARRAY;
     _importedLibrariesState = CacheState.ERROR;
     _includedParts = Source.EMPTY_ARRAY;
     _includedPartsState = CacheState.ERROR;
-    recordResolutionError();
+    recordResolutionError(exception);
   }
 
   /**
    * Record that the parse-related information for the associated source is about to be computed by
    * the current thread.
    */
   void recordParseInProcess() {
     if (_sourceKindState != CacheState.VALID) {
       _sourceKindState = CacheState.IN_PROCESS;
     }
@@ skipping 39 matching lines @@
     }
     if (_includedPartsState == CacheState.IN_PROCESS) {
       _includedPartsState = CacheState.INVALID;
     }
   }
 
   /**
    * Record that an error occurred while attempting to resolve the source 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.
+   *
+   * @param exception the exception that shows where the error occurred
    */
-  void recordResolutionError() {
+  void recordResolutionError(AnalysisException exception) {
+    this.exception = exception;
     _element = null;
     _elementState = CacheState.ERROR;
     clearFlags([_LAUNCHABLE_INDEX, _CLIENT_CODE_INDEX]);
+    _clientServerState = CacheState.ERROR;
+    _launchableState = CacheState.ERROR;
+    _publicNamespace = null;
+    _publicNamespaceState = CacheState.ERROR;
+    _resolutionState.recordResolutionErrorsInAllLibraries();
+  }
+
+  /**
+   * Record that an error occurred while attempting to resolve the source 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.
+   *
+   * @param librarySource the source of the library in which resolution was being performed
+   * @param exception the exception that shows where the error occurred
+   */
+  void recordResolutionErrorInLibrary(Source librarySource, AnalysisException exception) {
+    this.exception = exception;
+    _element = null;
+    _elementState = CacheState.ERROR;
+    clearFlags([_LAUNCHABLE_INDEX, _CLIENT_CODE_INDEX]);
     _clientServerState = CacheState.ERROR;
     _launchableState = CacheState.ERROR;
     _publicNamespace = null;
     _publicNamespaceState = CacheState.ERROR;
-    _resolutionState.recordResolutionError();
+    DartEntryImpl_ResolutionState state = _getOrCreateResolutionState(librarySource);
+    state.recordResolutionError();
   }
 
   /**
    * Record that an in-process resolution has stopped without recording results because the results
    * were invalidated before they could be recorded.
    */
   void recordResolutionNotInProcess() {
     if (_elementState == CacheState.IN_PROCESS) {
       _elementState = CacheState.INVALID;
     }
     if (_clientServerState == CacheState.IN_PROCESS) {
       _clientServerState = CacheState.INVALID;
     }
     if (_launchableState == CacheState.IN_PROCESS) {
       _launchableState = CacheState.INVALID;
     }
     // TODO(brianwilkerson) Remove the code above this line after resolution and element building
     // are separated.
     if (_publicNamespaceState == CacheState.IN_PROCESS) {
       _publicNamespaceState = CacheState.INVALID;
     }
     _resolutionState.recordResolutionNotInProcess();
   }
 
   /**
    * Record that an error occurred while attempting to scan or parse the entry represented by this
    * entry. This will set the state of all information, including any resolution-based information,
    * as being in error.
+   *
+   * @param exception the exception that shows where the error occurred
    */
-  void recordScanError() {
-    setState(SourceEntry.LINE_INFO, CacheState.ERROR);
+  @override
+  void recordScanError(AnalysisException exception) {
+    super.recordScanError(exception);
     _scanErrors = AnalysisError.NO_ERRORS;
     _scanErrorsState = CacheState.ERROR;
     _tokenStream = null;
     _tokenStreamState = CacheState.ERROR;
-    recordParseError();
+    recordParseError(exception);
   }
 
   /**
    * Record that the scan-related information for the associated source is about to be computed by
    * the current thread.
    */
   void recordScanInProcess() {
     if (getState(SourceEntry.LINE_INFO) != CacheState.VALID) {
       setState(SourceEntry.LINE_INFO, CacheState.IN_PROCESS);
     }
@@ skipping 15 matching lines @@
     }
     if (_scanErrorsState == CacheState.IN_PROCESS) {
       _scanErrorsState = CacheState.INVALID;
     }
     if (_tokenStreamState == CacheState.IN_PROCESS) {
       _tokenStreamState = CacheState.INVALID;
     }
   }
 
   /**
+   * Record that an error occurred while attempting to generate errors and warnings for the source
+   * represented by this entry. This will set the state of all verification information as being in
+   * error.
+   *
+   * @param librarySource the source of the library in which verification was being performed
+   * @param exception the exception that shows where the error occurred
+   */
+  void recordVerificationErrorInLibrary(Source librarySource, AnalysisException exception) {
+    this.exception = exception;
+    DartEntryImpl_ResolutionState state = _getOrCreateResolutionState(librarySource);
+    state.recordVerificationError();
+  }
+
+  /**
    * Remove the given library from the list of libraries that contain this part. This method should
    * only be invoked on entries that represent a part.
    *
    * @param librarySource the source of the library to be removed
    */
   void removeContainingLibrary(Source librarySource) {
     _containingLibraries.remove(librarySource);
   }
 
   /**
@@ skipping 465 matching lines @@
     _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 build the element model for the source
+   * represented by this state.
+   */
+  void recordBuildElementError() {
+    _builtUnitState = CacheState.ERROR;
+    _builtUnit = null;
+    _buildElementErrorsState = CacheState.ERROR;
+    _buildElementErrors = AnalysisError.NO_ERRORS;
+    recordResolutionError();
+  }
+
+  /**
+   * Record that an error occurred while attempting to generate hints for the source represented
+   * by this entry. This will set the state of all verification information as being in error.
+   */
+  void recordHintError() {
+    _hints = AnalysisError.NO_ERRORS;
+    _hintsState = CacheState.ERROR;
+  }
+
+  /**
+   * Record that an error occurred while attempting to resolve the source represented by this
+   * state.
+   */
+  void recordResolutionError() {
+    _resolvedUnitState = CacheState.ERROR;
+    _resolvedUnit = null;
+    _resolutionErrorsState = CacheState.ERROR;
+    _resolutionErrors = AnalysisError.NO_ERRORS;
+    recordVerificationError();
+  }
+
+  /**
    * 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() {
+  void recordResolutionErrorsInAllLibraries() {
     _builtUnitState = CacheState.ERROR;
     _builtUnit = null;
     _buildElementErrorsState = CacheState.ERROR;
     _buildElementErrors = AnalysisError.NO_ERRORS;
     _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;
+    recordVerificationError();
     if (_nextState != null) {
-      _nextState.recordResolutionError();
+      _nextState.recordResolutionErrorsInAllLibraries();
     }
   }
 
   /**
    * Record that an in-process parse has stopped without recording results because the results
    * were invalidated before they could be recorded.
    */
   void recordResolutionNotInProcess() {
     if (_resolvedUnitState == CacheState.IN_PROCESS) {
       _resolvedUnitState = CacheState.INVALID;
     }
     if (_resolutionErrorsState == CacheState.IN_PROCESS) {
       _resolutionErrorsState = CacheState.INVALID;
     }
     if (_verificationErrorsState == CacheState.IN_PROCESS) {
       _verificationErrorsState = CacheState.INVALID;
     }
     if (_hintsState == CacheState.IN_PROCESS) {
       _hintsState = CacheState.INVALID;
     }
     if (_nextState != null) {
       _nextState.recordResolutionNotInProcess();
     }
   }
 
   /**
+   * Record that an error occurred while attempting to generate errors and warnings for the source
+   * represented by this entry. This will set the state of all verification information as being
+   * in error.
+   */
+  void recordVerificationError() {
+    _verificationErrors = AnalysisError.NO_ERRORS;
+    _verificationErrorsState = CacheState.ERROR;
+    recordHintError();
+  }
+
+  /**
    * 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("; builtUnit = ");
       builder.append(_builtUnitState);
       builder.append("; buildElementErrors = ");
@@ skipping 806 matching lines @@
     _polymerResolutionErrorsState = CacheState.INVALID;
     _element = null;
     _elementState = CacheState.INVALID;
     _resolutionErrors = AnalysisError.NO_ERRORS;
     _resolutionErrorsState = CacheState.INVALID;
     _hints = AnalysisError.NO_ERRORS;
     _hintsState = CacheState.INVALID;
   }
 
   @override
-  void recordContentError() {
-    super.recordContentError();
-    recordParseError();
+  void recordContentError(AnalysisException exception) {
+    super.recordContentError(exception);
+    recordParseError(exception);
   }
 
   /**
    * Record that an error was encountered while attempting to parse the source associated with this
    * entry.
+   *
+   * @param exception the exception that shows where the error occurred
    */
-  void recordParseError() {
-    setState(SourceEntry.LINE_INFO, CacheState.ERROR);
-    setState(HtmlEntry.PARSE_ERRORS, CacheState.ERROR);
-    setState(HtmlEntry.PARSED_UNIT, CacheState.ERROR);
-    setState(HtmlEntry.REFERENCED_LIBRARIES, CacheState.ERROR);
-    recordResolutionError();
+  void recordParseError(AnalysisException exception) {
+    // If the scanning and parsing of HTML are separated, the following line can be removed.
+    recordScanError(exception);
+    _parseErrors = AnalysisError.NO_ERRORS;
+    _parseErrorsState = CacheState.ERROR;
+    _parsedUnit = null;
+    _parsedUnitState = CacheState.ERROR;
+    _referencedLibraries = Source.EMPTY_ARRAY;
+    _referencedLibrariesState = CacheState.ERROR;
+    recordResolutionError(exception);
   }
 
   /**
    * Record that an error was encountered while attempting to resolve the source associated with
    * this entry.
+   *
+   * @param exception the exception that shows where the error occurred
    */
-  void recordResolutionError() {
-    setState(HtmlEntry.ANGULAR_ERRORS, CacheState.ERROR);
-    setState(HtmlEntry.RESOLVED_UNIT, CacheState.ERROR);
-    setState(HtmlEntry.ELEMENT, CacheState.ERROR);
-    setState(HtmlEntry.RESOLUTION_ERRORS, CacheState.ERROR);
-    setState(HtmlEntry.HINTS, CacheState.ERROR);
-    setState(HtmlEntry.POLYMER_BUILD_ERRORS, CacheState.ERROR);
-    setState(HtmlEntry.POLYMER_RESOLUTION_ERRORS, CacheState.ERROR);
+  void recordResolutionError(AnalysisException exception) {
+    this.exception = exception;
+    _angularErrors = AnalysisError.NO_ERRORS;
+    _angularErrorsState = CacheState.ERROR;
+    _resolvedUnit = null;
+    _resolvedUnitState = CacheState.ERROR;
+    _element = null;
+    _elementState = CacheState.ERROR;
+    _resolutionErrors = AnalysisError.NO_ERRORS;
+    _resolutionErrorsState = CacheState.ERROR;
+    _hints = AnalysisError.NO_ERRORS;
+    _hintsState = CacheState.ERROR;
+    _polymerBuildErrors = AnalysisError.NO_ERRORS;
+    _polymerBuildErrorsState = CacheState.ERROR;
+    _polymerResolutionErrors = AnalysisError.NO_ERRORS;
+    _polymerResolutionErrorsState = CacheState.ERROR;
   }
 
   @override
   void setState(DataDescriptor descriptor, CacheState state) {
     if (identical(descriptor, HtmlEntry.ANGULAR_APPLICATION)) {
       _angularApplication = updatedValue(state, _angularApplication, null);
       _angularApplicationState = state;
     } else if (identical(descriptor, HtmlEntry.ANGULAR_COMPONENT)) {
       _angularComponent = updatedValue(state, _angularComponent, null);
       _angularComponentState = state;
@@ skipping 461 matching lines @@
   InstrumentedAnalysisContextImpl.con1(InternalAnalysisContext context) {
     _basis = context;
   }
 
   @override
   void addSourceInfo(Source source, SourceEntry info) {
     _basis.addSourceInfo(source, info);
   }
 
   @override
+  void applyAnalysisDelta(AnalysisDelta delta) {
+    InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-updateAnalysis");
+    _checkThread(instrumentation);
+    try {
+      instrumentation.metric3("contextId", _contextId);
+      _basis.applyAnalysisDelta(delta);
+    } finally {
+      instrumentation.log();
+    }
+  }
+
+  @override
   void applyChanges(ChangeSet changeSet) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-applyChanges");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       _basis.applyChanges(changeSet);
     } finally {
       instrumentation.log();
     }
   }
@@ skipping 443 matching lines @@
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getSourceFactory");
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.sourceFactory;
     } finally {
       instrumentation.log2(2);
     }
   }
 
   @override
-  AnalysisContentStatistics get statistics => _basis.statistics;
+  AnalysisContextStatistics get statistics => _basis.statistics;
 
   @override
   TypeProvider get typeProvider => _basis.typeProvider;
 
   @override
   bool isClientLibrary(Source librarySource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-isClientLibrary");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
@@ skipping 263 matching lines @@
    * library.
    *
    * @param library the library whose public namespace is to be returned
    * @return the public namespace of the given library
    */
   Namespace getPublicNamespace(LibraryElement library);
 
   /**
    * Returns a statistics about this context.
    */
-  AnalysisContentStatistics get statistics;
+  AnalysisContextStatistics get statistics;
 
   /**
    * Returns a type provider for this context or throws an exception if dart:core cannot be
    * resolved.
    *
    * @return the type provider (not `null`)
    * @throws AnalysisException if dart:core cannot be resolved
    */
   TypeProvider get typeProvider;
 
@@ skipping 2295 matching lines @@
       _errors = errorListener.getErrorsForSource(source);
     } on JavaException catch (exception) {
       throw new AnalysisException.con3(exception);
     } finally {
       timeCounterScan.stop();
     }
   }
 }
 
 /**
+ * Instances of the class `SdkAnalysisContext` implement an [AnalysisContext] that only
+ * contains sources for a Dart SDK.
+ */
+class SdkAnalysisContext extends AnalysisContextImpl {
+  @override
+  AnalysisCache createCacheFromSourceFactory(SourceFactory factory) {
+    if (factory == null) {
+      return super.createCacheFromSourceFactory(factory);
+    }
+    DartSdk sdk = factory.dartSdk;
+    if (sdk == null) {
+      throw new IllegalArgumentException("The source factory for an SDK analysis context must have a DartUriResolver");
+    }
+    return new AnalysisCache(<CachePartition> [AnalysisEngine.instance.partitionManager.forSdk(sdk)]);
+  }
+}
+
+/**
  * Instances of the class `SdkCachePartition` implement a cache partition that contains all of
  * the sources in the SDK.
  */
 class SdkCachePartition extends CachePartition {
   /**
    * Initialize a newly created partition.
    *
    * @param maxCacheSize the maximum number of sources for which AST structures should be kept in
    *          the cache
    */
@@ skipping 90 matching lines @@
   int _modificationTime = 0;
 
   /**
    * A bit-encoding of boolean flags associated with this element.
    */
   int _flags = 0;
 
   /**
    * The exception that caused one or more values to have a state of [CacheState#ERROR].
    */
-  AnalysisException exception;
+  AnalysisException _exception;
 
   /**
    * The state of the cached content.
    */
   CacheState _contentState = CacheState.INVALID;
 
   /**
    * The content of the source, or `null` if the content is not currently cached.
    */
   String _content;
@@ skipping 13 matching lines @@
    * The index of the flag indicating whether the source was explicitly added to the context or
    * whether the source was implicitly added because it was referenced by another source.
    */
   static int _EXPLICITLY_ADDED_FLAG = 0;
 
   /**
    * Fix the state of the [exception] to match the current state of the entry.
    */
   void fixExceptionState() {
     if (hasErrorState) {
-      if (exception == null) {
+      if (_exception == null) {
         //
         // This code should never be reached, but is a fail-safe in case an exception is not
         // recorded when it should be.
         //
-        exception = new AnalysisException.con1("State set to ERROR without setting an exception");
+        _exception = new AnalysisException.con1("State set to ERROR without setting an exception");
       }
     } else {
-      exception = null;
+      _exception = null;
     }
   }
 
   /**
+   * Return the exception that caused one or more values to have a state of [CacheState#ERROR]
+   * .
+   *
+   * @return the exception that caused one or more values to be uncomputable
+   */
+  @override
+  AnalysisException get exception => _exception;
+
+  /**
    * Return `true` if the source was explicitly added to the context or `false` if the
    * source was implicitly added because it was referenced by another source.
    *
    * @return `true` if the source was explicitly added to the context
    */
   @override
   bool get explicitlyAdded => getFlag(_EXPLICITLY_ADDED_FLAG);
 
   @override
   int get modificationTime => _modificationTime;
@@ skipping 27 matching lines @@
     _content = null;
     _contentState = _checkContentState(CacheState.INVALID);
     _lineInfo = null;
     _lineInfoState = CacheState.INVALID;
   }
 
   /**
    * Record that an error occurred while attempting to get the contents of the source represented by
    * this entry. This will set the state of all information, including any resolution-based
    * information, as being in error.
+   *
+   * @param exception the exception that shows where the error occurred
    */
-  void recordContentError() {
+  void recordContentError(AnalysisException exception) {
     _content = null;
     _contentState = CacheState.ERROR;
+    recordScanError(exception);
   }
 
   /**
+   * Record that an error occurred while attempting to scan or parse the entry represented by this
+   * entry. This will set the state of all information, including any resolution-based information,
+   * as being in error.
+   *
+   * @param exception the exception that shows where the error occurred
+   */
+  void recordScanError(AnalysisException exception) {
+    this.exception = exception;
+    _lineInfo = null;
+    _lineInfoState = CacheState.ERROR;
+  }
+
+  /**
    * Set whether the source was explicitly added to the context to match the given value.
    *
    * @param explicitlyAdded `true` if the source was explicitly added to the context
    */
   void set explicitlyAdded(bool explicitlyAdded) {
     setFlag(_EXPLICITLY_ADDED_FLAG, explicitlyAdded);
   }
 
   /**
    * Set the most recent time at which the state of the source matched the state represented by this
@@ skipping 60 matching lines @@
   }
 
   /**
    * Copy the information from the given cache entry.
    *
    * @param entry the cache entry from which information will be copied
    */
   void copyFrom(SourceEntryImpl entry) {
     _modificationTime = entry._modificationTime;
     _flags = entry._flags;
-    exception = entry.exception;
+    _exception = entry._exception;
     _contentState = entry._contentState;
     _content = entry._content;
     _lineInfoState = entry._lineInfoState;
     _lineInfo = entry._lineInfo;
   }
 
   /**
    * Return the value of the flag with the given index.
    *
    * @param index the index of the flag whose value is to be returned
    * @return the value of the flag with the given index
    */
   bool getFlag(int index) => BooleanArray.get(_flags, index);
 
   /**
    * Return `true` if the state of any data value is [CacheState#ERROR].
    *
    * @return `true` if the state of any data value is [CacheState#ERROR]
    */
   bool get hasErrorState => _contentState == CacheState.ERROR || _lineInfoState == CacheState.ERROR;
 
   /**
+   * Set the exception that caused one or more values to have a state of [CacheState#ERROR] to
+   * the given exception.
+   *
+   * @param exception the exception that caused one or more values to be uncomputable
+   */
+  void set exception(AnalysisException exception) {
+    if (exception == null) {
+      throw new IllegalArgumentException("exception cannot be null");
+    }
+    this._exception = exception;
+  }
+
+  /**
    * Set the value of the flag with the given index to the given value.
    *
    * @param index the index of the flag whose value is to be returned
    * @param value the value of the flag with the given index
    */
   void setFlag(int index, bool value) {
     _flags = BooleanArray.set(_flags, index, value);
   }
 
   /**
@@ skipping 340 matching lines @@
     _index++;
     if (_index >= WorkManager_this._workQueues[_queueIndex].length) {
       _index = 0;
       _queueIndex++;
       while (_queueIndex < WorkManager_this._workQueues.length && WorkManager_this._workQueues[_queueIndex].isEmpty) {
         _queueIndex++;
       }
     }
   }
 }