New analyzer snapshot (with CaughtException).

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 968 matching lines @@
         if (!source.isInSystemLibrary && (sourceEntry is DartEntry || sourceEntry is HtmlEntry)) {
           sourcesToInvalidate.add(source);
         }
       }
       int count = sourcesToInvalidate.length;
       for (int i = 0; i < count; i++) {
         Source source = sourcesToInvalidate[i];
         SourceEntry entry = _getReadableSourceEntry(source);
         if (entry is DartEntry) {
           DartEntry dartEntry = entry;
-          _removeFromParts(source, dartEntry);
           DartEntryImpl dartCopy = dartEntry.writableCopy;
           dartCopy.invalidateAllResolutionInformation();
           _cache.put(source, dartCopy);
           SourcePriority priority = SourcePriority.UNKNOWN;
           SourceKind kind = dartCopy.kind;
           if (kind == SourceKind.LIBRARY) {
             priority = SourcePriority.LIBRARY;
           } else if (kind == SourceKind.PART) {
             priority = SourcePriority.NORMAL_PART;
           }
@@ skipping 134 matching lines @@
     } on ObsoleteSourceAnalysisException catch (exception) {
       AnalysisEngine.instance.logger.logInformation2("Could not compute ${SourceEntry.LINE_INFO.toString()}", exception);
     }
     return null;
   }
 
   @override
   ResolvableCompilationUnit computeResolvableCompilationUnit(Source source) {
     DartEntry dartEntry = _getReadableDartEntry(source);
     if (dartEntry == null) {
-      throw new AnalysisException.con1("computeResolvableCompilationUnit for non-Dart: ${source.fullName}");
+      throw new AnalysisException("computeResolvableCompilationUnit for non-Dart: ${source.fullName}");
     }
     dartEntry = _cacheDartParseData(source, dartEntry, DartEntry.PARSED_UNIT);
     DartEntryImpl dartCopy = dartEntry.writableCopy;
     CompilationUnit unit = dartCopy.resolvableCompilationUnit;
     if (unit == null) {
-      throw new AnalysisException.con2("Internal error: computeResolvableCompilationUnit could not parse ${source.fullName}", dartEntry.exception);
+      throw new AnalysisException("Internal error: computeResolvableCompilationUnit could not parse ${source.fullName}", new CaughtException(dartEntry.exception, null));
     }
     _cache.put(source, dartCopy);
     return new ResolvableCompilationUnit.con1(dartCopy.modificationTime, unit);
   }
 
   @override
   void dispose() {
     _disposed = true;
   }
 
@@ skipping 272 matching lines @@
     }
     Namespace namespace = null;
     if (identical(dartEntry.getValue(DartEntry.ELEMENT), library)) {
       namespace = dartEntry.getValue(DartEntry.PUBLIC_NAMESPACE);
     }
     if (namespace == null) {
       NamespaceBuilder builder = new NamespaceBuilder();
       namespace = builder.createPublicNamespaceForLibrary(library);
       dartEntry = _getReadableDartEntry(source);
       if (dartEntry == null) {
-        AnalysisEngine.instance.logger.logError2("Could not compute the public namespace for ${library.source.fullName}", new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}"));
+        AnalysisEngine.instance.logger.logError2("Could not compute the public namespace for ${library.source.fullName}", new CaughtException(new AnalysisException("A Dart file became a non-Dart file: ${source.fullName}"), null));
         return null;
       }
       if (identical(dartEntry.getValue(DartEntry.ELEMENT), library)) {
         DartEntryImpl dartCopy = _getReadableDartEntry(source).writableCopy;
         dartCopy.setValue(DartEntry.PUBLIC_NAMESPACE, namespace);
         _cache.put(source, dartCopy);
       }
     }
     return namespace;
   }
@@ skipping 115 matching lines @@
       }
     }
     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");
+      throw new AnalysisException("Could not create a source for dart:core");
     }
     LibraryElement coreElement = computeLibraryElement(coreSource);
     if (coreElement == null) {
-      throw new AnalysisException.con1("Could not create an element for dart:core");
+      throw new AnalysisException("Could not create an element for dart:core");
     }
     return new TypeProviderImpl(coreElement);
   }
 
   @override
   bool isClientLibrary(Source librarySource) {
     SourceEntry sourceEntry = _getReadableSourceEntry(librarySource);
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       return dartEntry.getValue(DartEntry.IS_CLIENT) && dartEntry.getValue(DartEntry.IS_LAUNCHABLE);
@@ skipping 266 matching lines @@
   /**
    * 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;
+    CaughtException 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}");
+          throw new AnalysisException("A Dart file became a non-Dart file: ${unitSource.fullName}");
         }
         DartEntryImpl dartCopy = unitEntry.writableCopy;
         if (thrownException == null) {
-          dartCopy.recordResolutionError(new AnalysisException.con1("In recordResolveDartLibraryCycleTaskResults, resolvedLibraries was null and there was no thrown exception"));
+          dartCopy.recordResolutionError(new CaughtException(new AnalysisException("In recordResolveDartLibraryCycleTaskResults, resolvedLibraries was null and there was no thrown exception"), null));
         } else {
           dartCopy.recordResolutionError(thrownException);
         }
         _cache.put(unitSource, dartCopy);
         _cache.remove(unitSource);
         if (thrownException != null) {
           throw thrownException;
         }
         return dartCopy;
       }
@@ skipping 67 matching lines @@
         }
         _logInformation(writer.toString());
       }
     }
     if (thrownException != null) {
       throw thrownException;
     }
     if (unitEntry == null) {
       unitEntry = _getReadableDartEntry(unitSource);
       if (unitEntry == null) {
-        throw new AnalysisException.con1("A Dart file became a non-Dart file: ${unitSource.fullName}");
+        throw new AnalysisException("A Dart file became a non-Dart file: ${unitSource.fullName}");
       }
     }
     return unitEntry;
   }
 
   DartEntry recordResolveDartLibraryTaskResults(ResolveDartLibraryTask task) {
     LibraryResolver resolver = task.libraryResolver;
-    AnalysisException thrownException = task.exception;
+    CaughtException 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.
       //
       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}");
+          throw new AnalysisException("A Dart file became a non-Dart file: ${unitSource.fullName}");
         }
         DartEntryImpl dartCopy = unitEntry.writableCopy;
         if (thrownException == null) {
-          dartCopy.recordResolutionError(new AnalysisException.con1("In recordResolveDartLibraryTaskResults, resolvedLibraries was null and there was no thrown exception"));
+          dartCopy.recordResolutionError(new CaughtException(new AnalysisException("In recordResolveDartLibraryTaskResults, resolvedLibraries was null and there was no thrown exception"), null));
         } 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;
         for (Library 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);
             DartEntry dartEntry = _cache.get(source) as DartEntry;
             int sourceTime = getModificationStamp(source);
             if (dartEntry.modificationTime != sourceTime) {
               // The source has changed without the context being notified. Simulate notification.
               _sourceChanged(source);
               dartEntry = _getReadableDartEntry(source);
               if (dartEntry == null) {
-                throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
+                throw new AnalysisException("A Dart file became a non-Dart file: ${source.fullName}");
               }
             }
             DartEntryImpl dartCopy = dartEntry.writableCopy;
             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);
@@ skipping 51 matching lines @@
         }
         _logInformation(writer.toString());
       }
     }
     if (thrownException != null) {
       throw thrownException;
     }
     if (unitEntry == null) {
       unitEntry = _getReadableDartEntry(unitSource);
       if (unitEntry == null) {
-        throw new AnalysisException.con1("A Dart file became a non-Dart file: ${unitSource.fullName}");
+        throw new AnalysisException("A Dart file became a non-Dart file: ${unitSource.fullName}");
       }
     }
     return unitEntry;
   }
 
   /**
    * Record that we have accessed the AST structure associated with the given source. At the moment,
    * there is no differentiation between the parsed and resolved forms of the AST.
    *
    * @param source the source whose AST structure was accessed
@@ skipping 30 matching lines @@
    *           not happen)
    */
   bool _allModificationTimesMatch(List<ResolvableLibrary> resolvedLibraries) {
     bool allTimesMatch = true;
     for (ResolvableLibrary library in resolvedLibraries) {
       for (Source source in library.compilationUnitSources) {
         DartEntry dartEntry = _getReadableDartEntry(source);
         if (dartEntry == null) {
           // 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 resolve non-Dart file as a Dart file: ${source.fullName}");
+          throw new AnalysisException("Internal error: attempting to resolve non-Dart file as a Dart file: ${source.fullName}");
         }
         int sourceTime = getModificationStamp(source);
         int resultTime = library.getModificationTime(source);
         if (sourceTime != resultTime) {
           // The source has changed without the context being notified. Simulate notification.
           _sourceChanged(source);
           allTimesMatch = false;
         }
       }
     }
@@ skipping 10 matching lines @@
    *           not happen)
    */
   bool _allModificationTimesMatch2(Set<Library> resolvedLibraries) {
     bool allTimesMatch = true;
     for (Library library in resolvedLibraries) {
       for (Source source in library.compilationUnitSources) {
         DartEntry dartEntry = _getReadableDartEntry(source);
         if (dartEntry == null) {
           // 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 resolve non-Dart file as a Dart file: ${source.fullName}");
+          throw new AnalysisException("Internal error: attempting to resolve non-Dart file as a Dart file: ${source.fullName}");
         }
         int sourceTime = getModificationStamp(source);
         int resultTime = library.getModificationTime(source);
         if (sourceTime != resultTime) {
           // The source has changed without the context being notified. Simulate notification.
           _sourceChanged(source);
           allTimesMatch = false;
         }
       }
     }
@@ skipping 141 matching lines @@
       // If not, compute the information. Unless the modification date of the source continues to
       // change, this loop will eventually terminate.
       //
       try {
         if (dartEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) {
           dartEntry = new GetContentTask(this, source).perform(_resultRecorder) as DartEntry;
         }
         dartEntry = new ScanDartTask(this, source, dartEntry.modificationTime, dartEntry.getValue(SourceEntry.CONTENT)).perform(_resultRecorder) as DartEntry;
       } on AnalysisException catch (exception) {
         throw exception;
-      } on JavaException catch (exception) {
-        throw new AnalysisException.con3(exception);
+      } on JavaException catch (exception, stackTrace) {
+        throw new AnalysisException("Exception", new CaughtException(exception, stackTrace));
       }
       state = dartEntry.getState(descriptor);
     }
     return dartEntry;
   }
 
   /**
    * Given a source for a Dart file and the library that contains it, return a cache entry in which
    * the state of the data represented by the given descriptor is either [CacheState#VALID] or
    * [CacheState#ERROR]. This method assumes that the data can be produced by verifying the
@@ skipping 14 matching lines @@
     //
     CacheState state = dartEntry.getStateInLibrary(descriptor, librarySource);
     while (state != CacheState.ERROR && state != CacheState.VALID) {
       //
       // If not, compute the information. Unless the modification date of the source continues to
       // change, this loop will eventually terminate.
       //
       LibraryElement library = computeLibraryElement(librarySource);
       CompilationUnit unit = resolveCompilationUnit(unitSource, library);
       if (unit == null) {
-        throw new AnalysisException.con1("Could not resolve compilation unit ${unitSource.fullName} in ${librarySource.fullName}");
+        throw new AnalysisException("Could not resolve compilation unit ${unitSource.fullName} in ${librarySource.fullName}");
       }
       dartEntry = new GenerateDartErrorsTask(this, unitSource, dartEntry.modificationTime, unit, library).perform(_resultRecorder) as DartEntry;
       state = dartEntry.getStateInLibrary(descriptor, librarySource);
     }
     return dartEntry;
   }
 
   /**
    * Given a source for an HTML file, return a cache entry in which all of the data represented by
    * the state of the given descriptors is either [CacheState#VALID] or
@@ skipping 25 matching lines @@
       // If not, compute the information. Unless the modification date of the source continues to
       // change, this loop will eventually terminate.
       //
       try {
         if (htmlEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) {
           htmlEntry = new GetContentTask(this, source).perform(_resultRecorder) as HtmlEntry;
         }
         htmlEntry = new ParseHtmlTask(this, source, htmlEntry.modificationTime, htmlEntry.getValue(SourceEntry.CONTENT)).perform(_resultRecorder) as HtmlEntry;
       } on AnalysisException catch (exception) {
         throw exception;
-      } on JavaException catch (exception) {
-        throw new AnalysisException.con3(exception);
+      } on JavaException catch (exception, stackTrace) {
+        throw new AnalysisException("Exception", new CaughtException(exception, stackTrace));
       }
       state = htmlEntry.getState(descriptor);
     }
     return htmlEntry;
   }
 
   /**
    * Given a source for an HTML file, return a cache entry in which the state of the data
    * represented by the given descriptor is either [CacheState#VALID] or
    * [CacheState#ERROR]. This method assumes that the data can be produced by resolving the
@@ skipping 93 matching lines @@
       AnalysisContextImpl_CycleBuilder builder = new AnalysisContextImpl_CycleBuilder(this);
       builder.computeCycleContaining(source);
       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) {
+    } on AnalysisException catch (exception, stackTrace) {
       DartEntryImpl dartCopy = dartEntry.writableCopy;
-      dartCopy.recordBuildElementErrorInLibrary(source, exception);
+      dartCopy.recordBuildElementErrorInLibrary(source, new CaughtException(exception, stackTrace));
       _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 compute the next analysis task", new CaughtException(exception, stackTrace));
     }
     return new AnalysisContextImpl_TaskData(null, false);
   }
 
   /**
    * 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) {
-      AnalysisException exception = new AnalysisException.con1("Entry has VALID state for RESOLVED_UNIT but null value for ${unitSource.fullName} in ${librarySource.fullName}");
+      CaughtException exception = new CaughtException(new AnalysisException("Entry has VALID state for RESOLVED_UNIT but null value for ${unitSource.fullName} in ${librarySource.fullName}"), null);
       AnalysisEngine.instance.logger.logInformation2(exception.toString(), exception);
       DartEntryImpl dartCopy = unitEntry.writableCopy;
       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);
@@ skipping 175 matching lines @@
    */
   AnalysisContextImpl_TaskData _createResolveDartLibraryTask(Source source, DartEntry dartEntry) {
     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) {
+    } on AnalysisException catch (exception, stackTrace) {
       DartEntryImpl dartCopy = dartEntry.writableCopy;
-      dartCopy.recordResolutionError(exception);
+      dartCopy.recordResolutionError(new CaughtException(exception, stackTrace));
       _cache.put(source, dartCopy);
-      AnalysisEngine.instance.logger.logError2("Internal error trying to create a ResolveDartLibraryTask", exception);
+      AnalysisEngine.instance.logger.logError2("Internal error trying to create a ResolveDartLibraryTask", new CaughtException(exception, stackTrace));
     }
     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 1046 matching lines @@
    * Record the results produced by performing a [BuildDartElementModelTask]. 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 recorded results
    * @throws AnalysisException if the results could not be recorded
    */
   DartEntry _recordBuildDartElementModelTask(BuildDartElementModelTask task) {
     Source targetLibrary = task.targetLibrary;
     List<ResolvableLibrary> builtLibraries = task.librariesInCycle;
-    AnalysisException thrownException = task.exception;
+    CaughtException thrownException = task.exception;
     DartEntry targetEntry = null;
     if (_allModificationTimesMatch(builtLibraries)) {
       Source htmlSource = sourceFactory.forUri(DartSdk.DART_HTML);
       RecordingErrorListener errorListener = task.errorListener;
       for (ResolvableLibrary library in builtLibraries) {
         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);
@@ skipping 59 matching lines @@
         }
       }
       _logInformation(writer.toString());
     }
     if (thrownException != null) {
       throw thrownException;
     }
     if (targetEntry == null) {
       targetEntry = _getReadableDartEntry(targetLibrary);
       if (targetEntry == null) {
-        throw new AnalysisException.con1("A Dart file became a non-Dart file: ${targetLibrary.fullName}");
+        throw new AnalysisException("A Dart file became a non-Dart file: ${targetLibrary.fullName}");
       }
     }
     return targetEntry;
   }
 
   /**
    * Given a cache entry and a library element, record the library element and other information
    * gleaned from the element in the cache entry.
    *
    * @param dartCopy the cache entry in which data is to be recorded
@@ skipping 11 matching lines @@
    * Record the results produced by performing a [GenerateDartErrorsTask]. If the results were
    * computed from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   DartEntry _recordGenerateDartErrorsTask(GenerateDartErrorsTask task) {
     Source source = task.source;
     Source librarySource = task.libraryElement.source;
-    AnalysisException thrownException = task.exception;
+    CaughtException thrownException = task.exception;
     DartEntry dartEntry = null;
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       throw new ObsoleteSourceAnalysisException(source);
     } 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 verify non-Dart file as a Dart file: ${source.fullName}");
+      throw new AnalysisException("Internal error: attempting to verify non-Dart file as a Dart file: ${source.fullName}");
     }
     dartEntry = sourceEntry as DartEntry;
     int sourceTime = getModificationStamp(source);
     int resultTime = task.modificationTime;
     if (sourceTime == resultTime) {
       if (dartEntry.modificationTime != sourceTime) {
         // The source has changed without the context being notified. Simulate notification.
         _sourceChanged(source);
         dartEntry = _getReadableDartEntry(source);
         if (dartEntry == null) {
-          throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
+          throw new AnalysisException("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.recordVerificationErrorInLibrary(librarySource, thrownException);
       }
@@ skipping 33 matching lines @@
   /**
    * Record the results produced by performing a [GenerateDartHintsTask]. If the results were
    * computed from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   DartEntry _recordGenerateDartHintsTask(GenerateDartHintsTask task) {
     Source librarySource = task.libraryElement.source;
-    AnalysisException thrownException = task.exception;
+    CaughtException thrownException = task.exception;
     DartEntry libraryEntry = null;
     Map<Source, TimestampedData<List<AnalysisError>>> hintMap = task.hintMap;
     if (hintMap == null) {
       // We don't have any information about which sources to mark as invalid other than the library
       // source.
       SourceEntry sourceEntry = _cache.get(librarySource);
       if (sourceEntry == null) {
         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}");
+        throw new AnalysisException("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}");
+        thrownException = new CaughtException(new AnalysisException("GenerateDartHintsTask returned a null hint map without throwing an exception: ${librarySource.fullName}"), null);
       }
       DartEntryImpl dartCopy = (sourceEntry as DartEntry).writableCopy;
       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.
-        throw new AnalysisException.con1("Internal error: attempting to parse non-Dart file as a Dart file: ${unitSource.fullName}");
+        throw new AnalysisException("Internal error: attempting to parse non-Dart file as a Dart file: ${unitSource.fullName}");
       }
       DartEntry dartEntry = sourceEntry as DartEntry;
       if (unitSource == librarySource) {
         libraryEntry = dartEntry;
       }
       int sourceTime = getModificationStamp(unitSource);
       int resultTime = results.modificationTime;
       if (sourceTime == resultTime) {
         if (dartEntry.modificationTime != sourceTime) {
           // The source has changed without the context being notified. Simulate notification.
           _sourceChanged(unitSource);
           dartEntry = _getReadableDartEntry(unitSource);
           if (dartEntry == null) {
-            throw new AnalysisException.con1("A Dart file became a non-Dart file: ${unitSource.fullName}");
+            throw new AnalysisException("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.recordHintErrorInLibrary(librarySource, thrownException);
         }
@@ skipping 38 matching lines @@
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   SourceEntry _recordGetContentsTask(GetContentTask task) {
     if (!task.isComplete) {
       return null;
     }
     Source source = task.source;
-    AnalysisException thrownException = task.exception;
+    CaughtException thrownException = task.exception;
     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 {
@@ skipping 28 matching lines @@
   /**
    * Record the results produced by performing a [ParseDartTask]. 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 _recordParseDartTaskResults(ParseDartTask task) {
     Source source = task.source;
-    AnalysisException thrownException = task.exception;
+    CaughtException thrownException = task.exception;
     DartEntry dartEntry = null;
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       throw new ObsoleteSourceAnalysisException(source);
     } 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 parse non-Dart file as a Dart file: ${source.fullName}");
+      throw new AnalysisException("Internal error: attempting to parse non-Dart file as a Dart file: ${source.fullName}");
     }
     dartEntry = sourceEntry as DartEntry;
     int sourceTime = getModificationStamp(source);
     int resultTime = task.modificationTime;
     if (sourceTime == resultTime) {
       if (dartEntry.modificationTime != sourceTime) {
         // The source has changed without the context being notified. Simulate notification.
         _sourceChanged(source);
         dartEntry = _getReadableDartEntry(source);
         if (dartEntry == null) {
-          throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
+          throw new AnalysisException("A Dart file became a non-Dart file: ${source.fullName}");
         }
       }
       _removeFromParts(source, dartEntry);
       DartEntryImpl dartCopy = dartEntry.writableCopy;
       if (thrownException == null) {
         if (task.hasNonPartOfDirective) {
           dartCopy.setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY);
           dartCopy.containingLibrary = source;
           _workManager.add(source, SourcePriority.LIBRARY);
         } else if (task.hasPartOfDirective) {
@@ skipping 77 matching lines @@
   /**
    * Record the results produced by performing a [ParseHtmlTask]. 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
    */
   HtmlEntry _recordParseHtmlTaskResults(ParseHtmlTask task) {
     Source source = task.source;
-    AnalysisException thrownException = task.exception;
+    CaughtException thrownException = task.exception;
     HtmlEntry htmlEntry = null;
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       throw new ObsoleteSourceAnalysisException(source);
     } else if (sourceEntry is! HtmlEntry) {
       // This shouldn't be possible because we should never have performed the task if the source
       // didn't represent an HTML file, but check to be safe.
-      throw new AnalysisException.con1("Internal error: attempting to parse non-HTML file as a HTML file: ${source.fullName}");
+      throw new AnalysisException("Internal error: attempting to parse non-HTML file as a HTML file: ${source.fullName}");
     }
     htmlEntry = sourceEntry as HtmlEntry;
     int sourceTime = getModificationStamp(source);
     int resultTime = task.modificationTime;
     if (sourceTime == resultTime) {
       if (htmlEntry.modificationTime != sourceTime) {
         // The source has changed without the context being notified. Simulate notification.
         _sourceChanged(source);
         htmlEntry = _getReadableHtmlEntry(source);
         if (htmlEntry == null) {
-          throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
+          throw new AnalysisException("An HTML file became a non-HTML file: ${source.fullName}");
         }
       }
       HtmlEntryImpl htmlCopy = (sourceEntry as HtmlEntry).writableCopy;
       if (thrownException == null) {
         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);
@@ skipping 45 matching lines @@
 
   /**
    * Record the results produced by performing a [PolymerBuildHtmlTask]. 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
    * @throws AnalysisException if the results could not be recorded
    */
   HtmlEntry _recordPolymerBuildHtmlTaskResults(PolymerBuildHtmlTask task) {
     Source source = task.source;
-    AnalysisException thrownException = task.exception;
+    CaughtException thrownException = task.exception;
     HtmlEntry htmlEntry = null;
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       throw new ObsoleteSourceAnalysisException(source);
     } else if (sourceEntry is! HtmlEntry) {
       // This shouldn't be possible because we should never have performed the task if the source
       // didn't represent an HTML file, but check to be safe.
-      throw new AnalysisException.con1("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
+      throw new AnalysisException("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
     }
     htmlEntry = sourceEntry as HtmlEntry;
     int sourceTime = getModificationStamp(source);
     int resultTime = task.modificationTime;
     if (sourceTime == resultTime) {
       if (htmlEntry.modificationTime != sourceTime) {
         // The source has changed without the context being notified. Simulate notification.
         _sourceChanged(source);
         htmlEntry = _getReadableHtmlEntry(source);
         if (htmlEntry == null) {
-          throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
+          throw new AnalysisException("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(thrownException);
@@ skipping 29 matching lines @@
 
   /**
    * Record the results produced by performing a [PolymerResolveHtmlTask]. 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
    * @throws AnalysisException if the results could not be recorded
    */
   HtmlEntry _recordPolymerResolveHtmlTaskResults(PolymerResolveHtmlTask task) {
     Source source = task.source;
-    AnalysisException thrownException = task.exception;
+    CaughtException thrownException = task.exception;
     HtmlEntry htmlEntry = null;
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       throw new ObsoleteSourceAnalysisException(source);
     } else if (sourceEntry is! HtmlEntry) {
       // This shouldn't be possible because we should never have performed the task if the source
       // didn't represent an HTML file, but check to be safe.
-      throw new AnalysisException.con1("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
+      throw new AnalysisException("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
     }
     htmlEntry = sourceEntry as HtmlEntry;
     int sourceTime = getModificationStamp(source);
     int resultTime = task.modificationTime;
     if (sourceTime == resultTime) {
       if (htmlEntry.modificationTime != sourceTime) {
         // The source has changed without the context being notified. Simulate notification.
         _sourceChanged(source);
         htmlEntry = _getReadableHtmlEntry(source);
         if (htmlEntry == null) {
-          throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
+          throw new AnalysisException("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(thrownException);
@@ skipping 29 matching lines @@
 
   /**
    * Record the results produced by performing a [ResolveAngularComponentTemplateTask]. 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
    * @throws AnalysisException if the results could not be recorded
    */
   HtmlEntry _recordResolveAngularComponentTemplateTaskResults(ResolveAngularComponentTemplateTask task) {
     Source source = task.source;
-    AnalysisException thrownException = task.exception;
+    CaughtException thrownException = task.exception;
     HtmlEntry htmlEntry = null;
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       throw new ObsoleteSourceAnalysisException(source);
     } else if (sourceEntry is! HtmlEntry) {
       // This shouldn't be possible because we should never have performed the task if the source
       // didn't represent an HTML file, but check to be safe.
-      throw new AnalysisException.con1("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
+      throw new AnalysisException("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
     }
     htmlEntry = sourceEntry as HtmlEntry;
     int sourceTime = getModificationStamp(source);
     int resultTime = task.modificationTime;
     if (sourceTime == resultTime) {
       if (htmlEntry.modificationTime != sourceTime) {
         // The source has changed without the context being notified. Simulate notification.
         _sourceChanged(source);
         htmlEntry = _getReadableHtmlEntry(source);
         if (htmlEntry == null) {
-          throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
+          throw new AnalysisException("An HTML file became a non-HTML file: ${source.fullName}");
         }
       }
       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 {
@@ skipping 39 matching lines @@
 
   /**
    * Record the results produced by performing a [ResolveAngularEntryHtmlTask]. 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
    * @throws AnalysisException if the results could not be recorded
    */
   HtmlEntry _recordResolveAngularEntryHtmlTaskResults(ResolveAngularEntryHtmlTask task) {
     Source source = task.source;
-    AnalysisException thrownException = task.exception;
+    CaughtException thrownException = task.exception;
     HtmlEntry htmlEntry = null;
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       throw new ObsoleteSourceAnalysisException(source);
     } else if (sourceEntry is! HtmlEntry) {
       // This shouldn't be possible because we should never have performed the task if the source
       // didn't represent an HTML file, but check to be safe.
-      throw new AnalysisException.con1("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
+      throw new AnalysisException("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
     }
     htmlEntry = sourceEntry as HtmlEntry;
     int sourceTime = getModificationStamp(source);
     int resultTime = task.modificationTime;
     if (sourceTime == resultTime) {
       if (htmlEntry.modificationTime != sourceTime) {
         // The source has changed without the context being notified. Simulate notification.
         _sourceChanged(source);
         htmlEntry = _getReadableHtmlEntry(source);
         if (htmlEntry == null) {
-          throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
+          throw new AnalysisException("An HTML file became a non-HTML file: ${source.fullName}");
         }
       }
       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));
@@ skipping 42 matching lines @@
    * Record the results produced by performing a [ResolveDartUnitTask]. 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 _recordResolveDartUnitTaskResults(ResolveDartUnitTask task) {
     Source unitSource = task.source;
     Source librarySource = task.librarySource;
-    AnalysisException thrownException = task.exception;
+    CaughtException thrownException = task.exception;
     DartEntry dartEntry = null;
     SourceEntry sourceEntry = _cache.get(unitSource);
     if (sourceEntry == null) {
       throw new ObsoleteSourceAnalysisException(unitSource);
     } 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 resolve non-Dart file as a Dart file: ${unitSource.fullName}");
+      throw new AnalysisException("Internal error: attempting to resolve non-Dart file as a Dart file: ${unitSource.fullName}");
     }
     dartEntry = sourceEntry as DartEntry;
     int sourceTime = getModificationStamp(unitSource);
     int resultTime = task.modificationTime;
     if (sourceTime == resultTime) {
       if (dartEntry.modificationTime != sourceTime) {
         // The source has changed without the context being notified. Simulate notification.
         _sourceChanged(unitSource);
         dartEntry = _getReadableDartEntry(unitSource);
         if (dartEntry == null) {
-          throw new AnalysisException.con1("A Dart file became a non-Dart file: ${unitSource.fullName}");
+          throw new AnalysisException("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.recordResolutionErrorInLibrary(librarySource, thrownException);
         _cache.removedAst(unitSource);
       }
@@ skipping 35 matching lines @@
   /**
    * Record the results produced by performing a [ResolveHtmlTask]. 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
    */
   HtmlEntry _recordResolveHtmlTaskResults(ResolveHtmlTask task) {
     Source source = task.source;
-    AnalysisException thrownException = task.exception;
+    CaughtException thrownException = task.exception;
     HtmlEntry htmlEntry = null;
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       throw new ObsoleteSourceAnalysisException(source);
     } else if (sourceEntry is! HtmlEntry) {
       // This shouldn't be possible because we should never have performed the task if the source
       // didn't represent an HTML file, but check to be safe.
-      throw new AnalysisException.con1("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
+      throw new AnalysisException("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
     }
     htmlEntry = sourceEntry as HtmlEntry;
     int sourceTime = getModificationStamp(source);
     int resultTime = task.modificationTime;
     if (sourceTime == resultTime) {
       if (htmlEntry.modificationTime != sourceTime) {
         // The source has changed without the context being notified. Simulate notification.
         _sourceChanged(source);
         htmlEntry = _getReadableHtmlEntry(source);
         if (htmlEntry == null) {
-          throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
+          throw new AnalysisException("An HTML file became a non-HTML file: ${source.fullName}");
         }
       }
       HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
       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);
@@ skipping 42 matching lines @@
   /**
    * Record the results produced by performing a [ScanDartTask]. 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 _recordScanDartTaskResults(ScanDartTask task) {
     Source source = task.source;
-    AnalysisException thrownException = task.exception;
+    CaughtException thrownException = task.exception;
     DartEntry dartEntry = null;
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       throw new ObsoleteSourceAnalysisException(source);
     } 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 parse non-Dart file as a Dart file: ${source.fullName}");
+      throw new AnalysisException("Internal error: attempting to parse non-Dart file as a Dart file: ${source.fullName}");
     }
     dartEntry = sourceEntry as DartEntry;
     int sourceTime = getModificationStamp(source);
     int resultTime = task.modificationTime;
     if (sourceTime == resultTime) {
       if (dartEntry.modificationTime != sourceTime) {
         // The source has changed without the context being notified. Simulate notification.
         _sourceChanged(source);
         dartEntry = _getReadableDartEntry(source);
         if (dartEntry == null) {
-          throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
+          throw new AnalysisException("A Dart file became a non-Dart file: ${source.fullName}");
         }
       }
       DartEntryImpl dartCopy = dartEntry.writableCopy;
       if (thrownException == null) {
         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);
@@ skipping 183 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(new AnalysisException.con1("This source was marked as being deleted"));
+      htmlCopy.recordContentError(new CaughtException(new AnalysisException("This source was marked as being deleted"), null));
       _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(new AnalysisException.con1("This source was marked as being deleted"));
+      dartCopy.recordContentError(new CaughtException(new AnalysisException("This source was marked as being deleted"), null));
       _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 669 matching lines @@
  */
 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;
+  List<CaughtException> 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>();
+  Set<CaughtException> _exceptions = new Set<CaughtException>();
 
   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);
+  List<CaughtException> 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));
   }
@@ skipping 11 matching lines @@
 
   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;
+      CaughtException exception = dartEntry.exception;
       if (exception != null) {
         _exceptions.add(exception);
       }
     }
   }
 }
 
 class AnalysisContextStatisticsImpl_CacheRowImpl implements AnalysisContextStatistics_CacheRow {
   final String name;
 
@@ skipping 332 matching lines @@
   /**
    * Initialize an newly created error info with the errors and line information
    *
    * @param errors the errors as a result of analysis
    * @param lineinfo the line info for the errors
    */
   AnalysisErrorInfoImpl(this.errors, this.lineInfo);
 }
 
 /**
- * Instances of the class `AnalysisException` represent an exception that occurred during the
- * analysis of one or more sources.
- */
-class AnalysisException extends JavaException {
-  /**
-   * Initialize a newly created exception.
-   */
-  AnalysisException() : super();
-
-  /**
-   * Initialize a newly created exception to have the given message.
-   *
-   * @param message the message associated with the exception
-   */
-  AnalysisException.con1(String message) : super(message);
-
-  /**
-   * Initialize a newly created exception to have the given message and cause.
-   *
-   * @param message the message associated with the exception
-   * @param cause the underlying exception that caused this exception
-   */
-  AnalysisException.con2(String message, Exception cause) : super(message, cause);
-
-  /**
-   * 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);
 
   /**
@@ skipping 258 matching lines @@
 abstract class AnalysisTask {
   /**
    * The context in which the task is to be performed.
    */
   final InternalAnalysisContext context;
 
   /**
    * The exception that was thrown while performing this task, or `null` if the task completed
    * successfully.
    */
-  AnalysisException _thrownException;
+  CaughtException _thrownException;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    */
   AnalysisTask(this.context);
 
   /**
    * Use the given visitor to visit this task.
    *
    * @param visitor the visitor that should be used to visit this task
    * @return the value returned by the visitor
    * @throws AnalysisException if the visitor throws the exception
    */
   accept(AnalysisTaskVisitor visitor);
 
   /**
    * Return the exception that was thrown while performing this task, or `null` if the task
    * completed successfully.
    *
    * @return the exception that was thrown while performing this task
    */
-  AnalysisException get exception => _thrownException;
+  CaughtException get exception => _thrownException;
 
   /**
    * Perform this analysis task and use the given visitor to visit this task after it has completed.
    *
    * @param visitor the visitor used to visit this task after it has completed
    * @return the value returned by the visitor
    * @throws AnalysisException if the visitor throws the exception
    */
   Object perform(AnalysisTaskVisitor visitor) {
     try {
       _safelyPerform();
-    } on AnalysisException catch (exception) {
-      _thrownException = exception;
-      AnalysisEngine.instance.logger.logInformation2("Task failed: ${taskDescription}", exception);
+    } on AnalysisException catch (exception, stackTrace) {
+      _thrownException = new CaughtException(exception, stackTrace);
+      AnalysisEngine.instance.logger.logInformation2("Task failed: ${taskDescription}", new CaughtException(exception, stackTrace));
     }
     return accept(visitor);
   }
 
   @override
   String toString() => taskDescription;
 
   /**
    * Return a textual description of this task.
    *
@@ skipping 12 matching lines @@
    * Perform this analysis task, ensuring that all exceptions are wrapped in an
    * [AnalysisException].
    *
    * @throws AnalysisException if any exception occurs while performing the task
    */
   void _safelyPerform() {
     try {
       internalPerform();
     } on AnalysisException catch (exception) {
       throw exception;
-    } on JavaException catch (exception) {
-      throw new AnalysisException.con3(exception);
+    } on JavaException catch (exception, stackTrace) {
+      throw new AnalysisException("Exception", new CaughtException(exception, stackTrace));
     }
   }
 }
 
 /**
  * The interface `AnalysisTaskVisitor` defines the behavior of objects that can visit tasks.
  * While tasks are not structured in any interesting way, this class provides the ability to
  * dispatch to an appropriate method.
  */
 abstract class AnalysisTaskVisitor<E> {
@@ skipping 1130 matching lines @@
   void internalPerform() {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("dart.engine.BuildDartElementModel.internalPerform");
     try {
       //
       // Build the map of libraries that are known.
       //
       _libraryMap = _buildLibraryMap();
       _coreLibrary = _libraryMap[_coreLibrarySource];
       LibraryElement coreElement = _coreLibrary.libraryElement;
       if (coreElement == null) {
-        throw new AnalysisException.con1("Could not resolve dart:core");
+        throw new AnalysisException("Could not resolve dart:core");
       }
       instrumentation.metric3("buildLibraryMap", "complete");
       //
       // Build the element models representing the libraries being resolved. This is done in three
       // steps.
       //
       // 1. Build the basic element models without making any connections between elements other than
       //    the basic parent/child relationships. This includes building the elements representing the
       //    libraries.
       //
@@ skipping 446 matching lines @@
     for (int i = 0; i < _recentlyUsed.length; i++) {
       Source source = _recentlyUsed[i];
       RetentionPriority priority = _retentionPolicy.getAstPriority(source, _sourceMap[source]);
       if (priority == RetentionPriority.LOW) {
         return _recentlyUsed.removeAt(i);
       } else if (priority == RetentionPriority.MEDIUM && sourceToRemove < 0) {
         sourceToRemove = i;
       }
     }
     if (sourceToRemove < 0) {
-      AnalysisEngine.instance.logger.logError2("Internal error: Could not flush data from the cache", new JavaException());
+      // This happens if the retention policy returns a priority of HIGH for all of the sources that
+      // have been recently used. This is the case, for example, when the list of priority sources
+      // is bigger than the current cache size.
       return null;
     }
     return _recentlyUsed.removeAt(sourceToRemove);
   }
 }
 
 /**
  * Instances of the class `CacheRetentionPolicy` define the behavior of objects that determine
  * how important it is for data to be retained in the analysis cache.
  */
@@ skipping 1213 matching lines @@
   }
 
   /**
    * 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 recordBuildElementErrorInLibrary(Source librarySource, AnalysisException exception) {
+  void recordBuildElementErrorInLibrary(Source librarySource, CaughtException exception) {
     this.exception = exception;
     _element = null;
     _elementState = CacheState.ERROR;
     clearFlags([_LAUNCHABLE_INDEX, _CLIENT_CODE_INDEX]);
     _clientServerState = CacheState.ERROR;
     _launchableState = CacheState.ERROR;
     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(AnalysisException exception) {
+  void recordContentError(CaughtException 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) {
+  void recordHintErrorInLibrary(Source librarySource, CaughtException 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(AnalysisException exception) {
+  void recordParseError(CaughtException 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;
@@ skipping 56 matching lines @@
     }
   }
 
   /**
    * 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(AnalysisException exception) {
+  void recordResolutionError(CaughtException 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) {
+  void recordResolutionErrorInLibrary(Source librarySource, CaughtException 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;
     DartEntryImpl_ResolutionState state = _getOrCreateResolutionState(librarySource);
     state.recordResolutionError();
@@ skipping 22 matching lines @@
   }
 
   /**
    * 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
    */
   @override
-  void recordScanError(AnalysisException exception) {
+  void recordScanError(CaughtException exception) {
     super.recordScanError(exception);
     _scanErrors = AnalysisError.NO_ERRORS;
     _scanErrorsState = CacheState.ERROR;
     _tokenStream = null;
     _tokenStreamState = CacheState.ERROR;
     recordParseError(exception);
   }
 
   /**
    * Record that the scan-related information for the associated source is about to be computed by
@@ skipping 28 matching lines @@
   }
 
   /**
    * 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) {
+  void recordVerificationErrorInLibrary(Source librarySource, CaughtException 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
@@ skipping 963 matching lines @@
   @override
   String get taskDescription => "get contents of ${source.fullName}";
 
   @override
   void internalPerform() {
     _complete = true;
     try {
       TimestampedData<String> data = context.getContents(source);
       _content = data.data;
       _modificationTime = data.modificationTime;
-    } on JavaException catch (exception) {
-      throw new AnalysisException.con2("Could not get contents of ${source}", exception);
+    } on JavaException catch (exception, stackTrace) {
+      throw new AnalysisException("Could not get contents of ${source}", new CaughtException(exception, stackTrace));
     }
   }
 }
 
 /**
  * The interface `HtmlEntry` defines the behavior of objects that maintain the information
  * cached by an analysis context about an individual HTML file.
  */
 abstract class HtmlEntry implements SourceEntry {
   /**
@@ skipping 398 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(AnalysisException exception) {
+  void recordContentError(CaughtException 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(AnalysisException exception) {
+  void recordParseError(CaughtException 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(AnalysisException exception) {
+  void recordResolutionError(CaughtException 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;
@@ skipping 440 matching lines @@
    */
   static void _checkThread(InstrumentationBuilder instrumentation) {
   }
 
   /**
    * Record an exception that was thrown during analysis.
    *
    * @param instrumentation the instrumentation builder being used to record the exception
    * @param exception the exception being reported
    */
-  static void _recordAnalysisException(InstrumentationBuilder instrumentation, AnalysisException exception) {
+  static void _recordAnalysisException(InstrumentationBuilder instrumentation, CaughtException exception) {
     instrumentation.record(exception);
   }
 
   /**
    * The unique identifier used to identify this analysis context in the instrumentation data.
    */
   String _contextId = UUID.randomUUID().toString();
 
   /**
    * The analysis context to which all of the non-instrumentation work is delegated.
@@ skipping 74 matching lines @@
   @override
   List<Source> computeExportedLibraries(Source source) => _basis.computeExportedLibraries(source);
 
   @override
   HtmlElement computeHtmlElement(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeHtmlElement");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.computeHtmlElement(source);
-    } on AnalysisException catch (e) {
-      _recordAnalysisException(instrumentation, e);
+    } on AnalysisException catch (e, stackTrace) {
+      _recordAnalysisException(instrumentation, new CaughtException(e, stackTrace));
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
   @override
   List<Source> computeImportedLibraries(Source source) => _basis.computeImportedLibraries(source);
 
   @override
   SourceKind computeKindOf(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeKindOf");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.computeKindOf(source);
     } finally {
       instrumentation.log();
     }
   }
 
   @override
   LibraryElement computeLibraryElement(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeLibraryElement");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.computeLibraryElement(source);
-    } on AnalysisException catch (e) {
-      _recordAnalysisException(instrumentation, e);
+    } on AnalysisException catch (e, stackTrace) {
+      _recordAnalysisException(instrumentation, new CaughtException(e, stackTrace));
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
   @override
   LineInfo computeLineInfo(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeLineInfo");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.computeLineInfo(source);
-    } on AnalysisException catch (e) {
-      _recordAnalysisException(instrumentation, e);
+    } on AnalysisException catch (e, stackTrace) {
+      _recordAnalysisException(instrumentation, new CaughtException(e, stackTrace));
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
   @override
   ResolvableCompilationUnit computeResolvableCompilationUnit(Source source) => _basis.computeResolvableCompilationUnit(source);
 
   @override
@@ skipping 412 matching lines @@
     }
   }
 
   @override
   CompilationUnit parseCompilationUnit(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-parseCompilationUnit");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.parseCompilationUnit(source);
-    } on AnalysisException catch (e) {
-      _recordAnalysisException(instrumentation, e);
+    } on AnalysisException catch (e, stackTrace) {
+      _recordAnalysisException(instrumentation, new CaughtException(e, stackTrace));
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
   @override
   ht.HtmlUnit parseHtmlUnit(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-parseHtmlUnit");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.parseHtmlUnit(source);
-    } on AnalysisException catch (e) {
-      _recordAnalysisException(instrumentation, e);
+    } on AnalysisException catch (e, stackTrace) {
+      _recordAnalysisException(instrumentation, new CaughtException(e, stackTrace));
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
   @override
   AnalysisResult performAnalysisTask() {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-performAnalysisTask");
     _checkThread(instrumentation);
@@ skipping 14 matching lines @@
     _basis.recordLibraryElements(elementMap);
   }
 
   @override
   CompilationUnit resolveCompilationUnit(Source unitSource, LibraryElement library) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-resolveCompilationUnit");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.resolveCompilationUnit(unitSource, library);
-    } on AnalysisException catch (e) {
-      _recordAnalysisException(instrumentation, e);
+    } on AnalysisException catch (e, stackTrace) {
+      _recordAnalysisException(instrumentation, new CaughtException(e, stackTrace));
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
   @override
   CompilationUnit resolveCompilationUnit2(Source unitSource, Source librarySource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-resolveCompilationUnit");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.resolveCompilationUnit2(unitSource, librarySource);
-    } on AnalysisException catch (e) {
-      _recordAnalysisException(instrumentation, e);
+    } on AnalysisException catch (e, stackTrace) {
+      _recordAnalysisException(instrumentation, new CaughtException(e, stackTrace));
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
   @override
   ht.HtmlUnit resolveHtmlUnit(Source htmlSource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-resolveHtmlUnit");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.resolveHtmlUnit(htmlSource);
-    } on AnalysisException catch (e) {
-      _recordAnalysisException(instrumentation, e);
+    } on AnalysisException catch (e, stackTrace) {
+      _recordAnalysisException(instrumentation, new CaughtException(e, stackTrace));
       throw e;
     } finally {
       instrumentation.log();
     }
   }
 
   @override
   void set analysisOptions(AnalysisOptions options) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-setAnalysisOptions");
     _checkThread(instrumentation);
@@ skipping 462 matching lines @@
   /**
    * The source that was removed while it was being analyzed.
    */
   Source _source;
 
   /**
    * Initialize a newly created exception to represent the removal of the given source.
    *
    * @param source the source that was removed while it was being analyzed
    */
-  ObsoleteSourceAnalysisException(Source source) : super.con1("The source '${source.fullName}' was removed while it was being analyzed") {
+  ObsoleteSourceAnalysisException(Source source) : super("The source '${source.fullName}' was removed while it was being analyzed") {
     this._source = source;
   }
 
   /**
    * Return the source that was removed while it was being analyzed.
    *
    * @return the source that was removed
    */
   Source get source => _source;
 }
@@ skipping 198 matching lines @@
             if (referencedSource != null) {
               if (directive is ExportDirective) {
                 _exportedSources.add(referencedSource);
               } else if (directive is ImportDirective) {
                 _importedSources.add(referencedSource);
               } else if (directive is PartDirective) {
                 if (referencedSource != source) {
                   _includedSources.add(referencedSource);
                 }
               } else {
-                throw new AnalysisException.con1("${runtimeType.toString()} failed to handle a ${directive.runtimeType.toString()}");
+                throw new AnalysisException("${runtimeType.toString()} failed to handle a ${directive.runtimeType.toString()}");
               }
             }
           }
         }
       }
       _errors = errorListener.getErrorsForSource(source);
     } finally {
       timeCounterParse.stop();
     }
   }
@@ skipping 118 matching lines @@
     try {
       ht.AbstractScanner scanner = new ht.StringScanner(source, _content);
       scanner.passThroughElements = <String> [_TAG_SCRIPT];
       ht.Token token = scanner.tokenize();
       _lineInfo = new LineInfo(scanner.lineStarts);
       RecordingErrorListener errorListener = new RecordingErrorListener();
       _unit = new ht.HtmlParser(source, errorListener).parse(token, _lineInfo);
       _unit.accept(new RecursiveXmlVisitor_ParseHtmlTask_internalPerform(this, errorListener));
       _errors = errorListener.getErrorsForSource(source);
       _referencedLibraries = librarySources;
-    } on JavaException catch (exception) {
-      throw new AnalysisException.con3(exception);
+    } on JavaException catch (exception, stackTrace) {
+      throw new AnalysisException("Exception", new CaughtException(exception, stackTrace));
     }
   }
 
   /**
    * Return the sources of libraries that are referenced in the specified HTML file.
    *
    * @return the sources of libraries that are referenced in the HTML file
    */
   List<Source> get librarySources {
     List<Source> libraries = new List<Source>();
@@ skipping 1318 matching lines @@
     return "resolve unit ${librarySource.fullName}";
   }
 
   @override
   void internalPerform() {
     TypeProvider typeProvider = (_libraryElement.context as InternalAnalysisContext).typeProvider;
     ResolvableCompilationUnit resolvableUnit = context.computeResolvableCompilationUnit(source);
     _modificationTime = resolvableUnit.modificationTime;
     CompilationUnit unit = resolvableUnit.compilationUnit;
     if (unit == null) {
-      throw new AnalysisException.con1("Internal error: computeResolvableCompilationUnit returned a value without a parsed Dart unit");
+      throw new AnalysisException("Internal error: computeResolvableCompilationUnit returned a value without a parsed Dart unit");
     }
     //
     // Resolve names in declarations.
     //
     new DeclarationResolver().resolve(unit, _find(_libraryElement, source));
     //
     // Resolve the type names.
     //
     RecordingErrorListener errorListener = new RecordingErrorListener();
     TypeResolverVisitor typeResolverVisitor = new TypeResolverVisitor.con2(_libraryElement, source, typeProvider, errorListener);
@@ skipping 246 matching lines @@
   @override
   void internalPerform() {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     TimeCounter_TimeCounterHandle timeCounterScan = PerformanceStatistics.scan.start();
     try {
       Scanner scanner = new Scanner(source, new CharSequenceReader(_content), errorListener);
       scanner.preserveComments = context.analysisOptions.preserveComments;
       _tokenStream = scanner.tokenize();
       _lineInfo = new LineInfo(scanner.lineStarts);
       _errors = errorListener.getErrorsForSource(source);
-    } on JavaException catch (exception) {
-      throw new AnalysisException.con3(exception);
+    } on JavaException catch (exception, stackTrace) {
+      throw new AnalysisException("Exception", new CaughtException(exception, stackTrace));
     } finally {
       timeCounterScan.stop();
     }
   }
 }
 
 /**
  * Instances of the class `SdkAnalysisContext` implement an [AnalysisContext] that only
  * contains sources for a Dart SDK.
  */
@@ skipping 45 matching lines @@
    * The data descriptor representing the line information.
    */
   static final DataDescriptor<LineInfo> LINE_INFO = new DataDescriptor<LineInfo>("SourceEntry.LINE_INFO");
 
   /**
    * 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
    */
-  AnalysisException get exception;
+  CaughtException get 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
    */
   bool get explicitlyAdded;
 
   /**
@@ skipping 49 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;
+  CaughtException _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 18 matching lines @@
   /**
    * Fix the state of the [exception] to match the current state of the entry.
    */
   void fixExceptionState() {
     if (hasErrorState) {
       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 CaughtException(new AnalysisException("State set to ERROR without setting an exception"), null);
       }
     } else {
       _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;
+  CaughtException 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);
 
@@ skipping 32 matching lines @@
     _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(AnalysisException exception) {
+  void recordContentError(CaughtException 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) {
+  void recordScanError(CaughtException 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
    */
@@ skipping 94 matching lines @@
    * @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) {
+  void set exception(CaughtException 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
@@ skipping 347 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++;
       }
     }
   }
 }