Add (an as yet unused) task

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 'dart:collection';
+
+import 'package:analyzer/src/task/task_dart.dart';
+
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'utilities_collection.dart';
 import 'utilities_general.dart';
 import 'instrumentation.dart';
 import 'error.dart';
 import 'source.dart';
 import 'scanner.dart';
 import 'ast.dart';
 import 'parser.dart' show Parser, IncrementalParser;
@@ skipping 2450 matching lines @@
   bool _containsAny(List<Source> sources, List<Source> targetSources) {
     for (Source targetSource in targetSources) {
       if (_contains(sources, targetSource)) {
         return true;
       }
     }
     return false;
   }
 
   /**
+   * Create a [BuildUnitElementTask] for the given [source].
+   */
+  AnalysisContextImpl_TaskData _createBuildUnitElementTask(Source source, DartEntry dartEntry, Source librarySource) {
+    CompilationUnit unit = dartEntry.resolvableCompilationUnit;
+    if (unit == null) {
+      return _createParseDartTask(source, dartEntry);
+    }
+    return new AnalysisContextImpl_TaskData(
+        new BuildUnitElementTask(this, source, librarySource, unit),
+        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
    */
@@ skipping 55 matching lines @@
    * @param source the source whose content is to be accessed
    * @param sourceEntry the entry for the source
    * @return task data representing the created task
    */
   AnalysisContextImpl_TaskData _createGetContentTask(Source source, SourceEntry sourceEntry) {
     sourceEntry.setState(SourceEntry.CONTENT, CacheState.IN_PROCESS);
     return new AnalysisContextImpl_TaskData(new GetContentTask(this, source), false);
   }
 
   /**
-   * Create a [ParseDartTask] for the given source, marking the parse errors as being
-   * in-process.
-   *
-   * @param source the source whose content is to be parsed
-   * @param dartEntry the entry for the source
-   * @return task data representing the created task
+   * Create a [ParseDartTask] for the given [source].
    */
   AnalysisContextImpl_TaskData _createParseDartTask(Source source, DartEntry dartEntry) {
     if (dartEntry.getState(DartEntry.TOKEN_STREAM) != CacheState.VALID || dartEntry.getState(SourceEntry.LINE_INFO) != CacheState.VALID) {
       return _createScanDartTask(source, dartEntry);
     }
     Token tokenStream = dartEntry.getValue(DartEntry.TOKEN_STREAM);
     dartEntry.setState(DartEntry.TOKEN_STREAM, CacheState.FLUSHED);
     dartEntry.setState(DartEntry.PARSE_ERRORS, CacheState.IN_PROCESS);
     return new AnalysisContextImpl_TaskData(new ParseDartTask(this, source, tokenStream, dartEntry.getValue(SourceEntry.LINE_INFO)), false);
   }
 
   /**
-   * Create a [ParseHtmlTask] for the given source, marking the parse errors as being
-   * in-process.
-   *
-   * @param source the source whose content is to be parsed
-   * @param htmlEntry the entry for the source
-   * @return task data representing the created task
+   * Create a [ParseHtmlTask] for the given [source].
    */
   AnalysisContextImpl_TaskData _createParseHtmlTask(Source source, HtmlEntry htmlEntry) {
     if (htmlEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) {
       return _createGetContentTask(source, htmlEntry);
     }
     String content = htmlEntry.getValue(SourceEntry.CONTENT);
     htmlEntry.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
     htmlEntry.setState(HtmlEntry.PARSE_ERRORS, CacheState.IN_PROCESS);
     return new AnalysisContextImpl_TaskData(new ParseHtmlTask(this, source, content), false);
   }
@@ skipping 1214 matching lines @@
         // notify about Dart errors
         ChangeNoticeImpl notice = _getNotice(elementSource);
         notice.setErrors(dartEntry.allErrors, computeLineInfo(elementSource));
       }
     }
     // remember Angular entry point
     entry.setValue(HtmlEntry.ANGULAR_ENTRY, application);
   }
 
   /**
+   * Record the results produced by performing a [task] and return the cache
+   * entry associated with the results.
+   */
+  DartEntry _recordBuildUnitElementTask(BuildUnitElementTask task) {
+    Source source = task.source;
+    Source library = task.library;
+    DartEntry dartEntry = _cache.get(source);
+    CaughtException thrownException = task.exception;
+    if (thrownException != null) {
+      dartEntry.recordBuildElementErrorInLibrary(library, thrownException);
+      throw new AnalysisException('<rethrow>', thrownException);
+    }
+    dartEntry.setValueInLibrary(DartEntry.BUILT_UNIT, library, task.unit);
+    dartEntry.setValueInLibrary(DartEntry.BUILT_ELEMENT, library, task.unitElement);
+    ChangeNoticeImpl notice = _getNotice(source);
+    LineInfo lineInfo = dartEntry.getValue(SourceEntry.LINE_INFO);
+    notice.setErrors(dartEntry.allErrors, lineInfo);
+    return dartEntry;
+  }
+
+  /**
    * Given a cache entry and a library element, record the library element and other information
    * gleaned from the element in the cache entry.
    *
    * @param dartCopy the cache entry in which data is to be recorded
    * @param library the library element used to record information
    * @param librarySource the source for the library used to record information
    * @param htmlSource the source for the HTML library
    */
   void _recordElementData(DartEntry dartEntry, LibraryElement library, Source librarySource, Source htmlSource) {
     dartEntry.setValue(DartEntry.ELEMENT, library);
@@ skipping 10 matching lines @@
     DartEntry dartEntry = _cache.get(source);
     Source librarySource = task.libraryElement.source;
     CaughtException thrownException = task.exception;
     if (thrownException != null) {
       dartEntry.recordVerificationErrorInLibrary(librarySource, thrownException);
       throw new AnalysisException('<rethrow>', thrownException);
     }
     dartEntry.setValueInLibrary(
         DartEntry.VERIFICATION_ERRORS,
         librarySource,
-            task.errors);
+        task.errors);
     ChangeNoticeImpl notice = _getNotice(source);
     LineInfo lineInfo = dartEntry.getValue(SourceEntry.LINE_INFO);
     notice.setErrors(dartEntry.allErrors, lineInfo);
     return dartEntry;
   }
 
   /**
    * Record the results produced by performing a [task] and return the cache
    * entry associated with the results.
    */
@@ skipping 549 matching lines @@
         writer.print("    ");
         writer.println(source.fullName);
       }
       _logInformation(writer.toString());
     }
     return changedSources.length > 0;
   }
 }
 
 /**
- * Instances of the class `AnalysisTaskResultRecorder` are used by an analysis context to
- * record the results of a task.
+ * An `AnalysisTaskResultRecorder` is used by an analysis context to record the
+ * results of a task.
  */
 class AnalysisContextImpl_AnalysisTaskResultRecorder implements AnalysisTaskVisitor<SourceEntry> {
   final AnalysisContextImpl AnalysisContextImpl_this;
 
   AnalysisContextImpl_AnalysisTaskResultRecorder(this.AnalysisContextImpl_this);
 
   @override
-  DartEntry visitGenerateDartErrorsTask(GenerateDartErrorsTask task) => AnalysisContextImpl_this._recordGenerateDartErrorsTask(task);
+  DartEntry visitBuildUnitElementTask(BuildUnitElementTask task)
+      => AnalysisContextImpl_this._recordBuildUnitElementTask(task);
 
   @override
-  DartEntry visitGenerateDartHintsTask(GenerateDartHintsTask task) => AnalysisContextImpl_this._recordGenerateDartHintsTask(task);
+  DartEntry visitGenerateDartErrorsTask(GenerateDartErrorsTask task)
+      => AnalysisContextImpl_this._recordGenerateDartErrorsTask(task);
 
   @override
-  SourceEntry visitGetContentTask(GetContentTask task) => AnalysisContextImpl_this._recordGetContentsTask(task);
+  DartEntry visitGenerateDartHintsTask(GenerateDartHintsTask task)
+      => AnalysisContextImpl_this._recordGenerateDartHintsTask(task);
 
   @override
-  DartEntry visitIncrementalAnalysisTask(IncrementalAnalysisTask task) => AnalysisContextImpl_this._recordIncrementalAnalysisTaskResults(task);
+  SourceEntry visitGetContentTask(GetContentTask task)
+      => AnalysisContextImpl_this._recordGetContentsTask(task);
 
   @override
-  DartEntry visitParseDartTask(ParseDartTask task) => AnalysisContextImpl_this._recordParseDartTaskResults(task);
+  DartEntry visitIncrementalAnalysisTask(IncrementalAnalysisTask task)
+      => AnalysisContextImpl_this._recordIncrementalAnalysisTaskResults(task);
 
   @override
-  HtmlEntry visitParseHtmlTask(ParseHtmlTask task) => AnalysisContextImpl_this._recordParseHtmlTaskResults(task);
+  DartEntry visitParseDartTask(ParseDartTask task)
+      => AnalysisContextImpl_this._recordParseDartTaskResults(task);
 
   @override
-  HtmlEntry visitPolymerBuildHtmlTask(PolymerBuildHtmlTask task) => AnalysisContextImpl_this._recordPolymerBuildHtmlTaskResults(task);
+  HtmlEntry visitParseHtmlTask(ParseHtmlTask task)
+      => AnalysisContextImpl_this._recordParseHtmlTaskResults(task);
 
   @override
-  HtmlEntry visitPolymerResolveHtmlTask(PolymerResolveHtmlTask task) => AnalysisContextImpl_this._recordPolymerResolveHtmlTaskResults(task);
+  HtmlEntry visitPolymerBuildHtmlTask(PolymerBuildHtmlTask task)
+      => AnalysisContextImpl_this._recordPolymerBuildHtmlTaskResults(task);
 
   @override
-  HtmlEntry visitResolveAngularComponentTemplateTask(ResolveAngularComponentTemplateTask task) => AnalysisContextImpl_this._recordResolveAngularComponentTemplateTaskResults(task);
+  HtmlEntry visitPolymerResolveHtmlTask(PolymerResolveHtmlTask task)
+      => AnalysisContextImpl_this._recordPolymerResolveHtmlTaskResults(task);
 
   @override
-  HtmlEntry visitResolveAngularEntryHtmlTask(ResolveAngularEntryHtmlTask task) => AnalysisContextImpl_this._recordResolveAngularEntryHtmlTaskResults(task);
+  HtmlEntry visitResolveAngularComponentTemplateTask(ResolveAngularComponentTemplateTask task)
+      => AnalysisContextImpl_this._recordResolveAngularComponentTemplateTaskResults(task);
 
   @override
-  DartEntry visitResolveDartLibraryCycleTask(ResolveDartLibraryCycleTask task) => AnalysisContextImpl_this.recordResolveDartLibraryCycleTaskResults(task);
+  HtmlEntry visitResolveAngularEntryHtmlTask(ResolveAngularEntryHtmlTask task)
+      => AnalysisContextImpl_this._recordResolveAngularEntryHtmlTaskResults(task);
 
   @override
-  DartEntry visitResolveDartLibraryTask(ResolveDartLibraryTask task) => AnalysisContextImpl_this.recordResolveDartLibraryTaskResults(task);
+  DartEntry visitResolveDartLibraryCycleTask(ResolveDartLibraryCycleTask task)
+      => AnalysisContextImpl_this.recordResolveDartLibraryCycleTaskResults(task);
 
   @override
-  DartEntry visitResolveDartUnitTask(ResolveDartUnitTask task) => AnalysisContextImpl_this._recordResolveDartUnitTaskResults(task);
+  DartEntry visitResolveDartLibraryTask(ResolveDartLibraryTask task)
+      => AnalysisContextImpl_this.recordResolveDartLibraryTaskResults(task);
 
   @override
-  HtmlEntry visitResolveHtmlTask(ResolveHtmlTask task) => AnalysisContextImpl_this._recordResolveHtmlTaskResults(task);
+  DartEntry visitResolveDartUnitTask(ResolveDartUnitTask task)
+      => AnalysisContextImpl_this._recordResolveDartUnitTaskResults(task);
 
   @override
-  DartEntry visitScanDartTask(ScanDartTask task) => AnalysisContextImpl_this._recordScanDartTaskResults(task);
+  HtmlEntry visitResolveHtmlTask(ResolveHtmlTask task)
+      => AnalysisContextImpl_this._recordResolveHtmlTaskResults(task);
+
+  @override
+  DartEntry visitScanDartTask(ScanDartTask task)
+      => AnalysisContextImpl_this._recordScanDartTaskResults(task);
 }
 
 class AnalysisContextImpl_ContextRetentionPolicy implements CacheRetentionPolicy {
   final AnalysisContextImpl AnalysisContextImpl_this;
 
   AnalysisContextImpl_ContextRetentionPolicy(this.AnalysisContextImpl_this);
 
   @override
   RetentionPriority getAstPriority(Source source, SourceEntry sourceEntry) {
     int priorityCount = AnalysisContextImpl_this._priorityOrder.length;
@@ skipping 1454 matching lines @@
       internalPerform();
     } on AnalysisException catch (exception) {
       throw exception;
     } catch (exception, stackTrace) {
       throw new AnalysisException(exception.toString(), 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.
+ * An `AnalysisTaskVisitor` visits tasks. While tasks are not structured in any
+ * interesting way, this class provides the ability to dispatch to an
+ * appropriate method.
  */
 abstract class AnalysisTaskVisitor<E> {
   /**
-   * Visit a [GenerateDartErrorsTask].
-   *
-   * @param task the task to be visited
-   * @return the result of visiting the task
-   * @throws AnalysisException if the visitor throws an exception for some reason
+   * Visit the given [task], returning the result of the visit. This method will
+   * throw an AnalysisException if the visitor throws an exception.
+   */
+  E visitBuildUnitElementTask(BuildUnitElementTask task);
+
+  /**
+   * Visit the given [task], returning the result of the visit. This method will
+   * throw an AnalysisException if the visitor throws an exception.
    */
   E visitGenerateDartErrorsTask(GenerateDartErrorsTask task);
 
   /**
-   * Visit a [GenerateDartHintsTask].
-   *
-   * @param task the task to be visited
-   * @return the result of visiting the task
-   * @throws AnalysisException if the visitor throws an exception for some reason
+   * Visit the given [task], returning the result of the visit. This method will
+   * throw an AnalysisException if the visitor throws an exception.
    */
   E visitGenerateDartHintsTask(GenerateDartHintsTask task);
 
   /**
-   * Visit a [GetContentTask].
-   *
-   * @param task the task to be visited
-   * @return the result of visiting the task
-   * @throws AnalysisException if the visitor throws an exception for some reason
+   * Visit the given [task], returning the result of the visit. This method will
+   * throw an AnalysisException if the visitor throws an exception.
    */
   E visitGetContentTask(GetContentTask task);
 
   /**
-   * Visit an [IncrementalAnalysisTask].
-   *
-   * @param task the task to be visited
-   * @return the result of visiting the task
-   * @throws AnalysisException if the visitor throws an exception for some reason
+   * Visit the given [task], returning the result of the visit. This method will
+   * throw an AnalysisException if the visitor throws an exception.
    */
   E visitIncrementalAnalysisTask(IncrementalAnalysisTask incrementalAnalysisTask);
 
   /**
-   * Visit a [ParseDartTask].
-   *
-   * @param task the task to be visited
-   * @return the result of visiting the task
-   * @throws AnalysisException if the visitor throws an exception for some reason
+   * Visit the given [task], returning the result of the visit. This method will
+   * throw an AnalysisException if the visitor throws an exception.
    */
   E visitParseDartTask(ParseDartTask task);
 
   /**
-   * Visit a [ParseHtmlTask].
-   *
-   * @param task the task to be visited
-   * @return the result of visiting the task
-   * @throws AnalysisException if the visitor throws an exception for some reason
+   * Visit the given [task], returning the result of the visit. This method will
+   * throw an AnalysisException if the visitor throws an exception.
    */
   E visitParseHtmlTask(ParseHtmlTask task);
 
   /**
-   * Visit a [PolymerBuildHtmlTask].
-   *
-   * @param task the task to be visited
-   * @return the result of visiting the task
-   * @throws AnalysisException if the visitor throws an exception for some reason
+   * Visit the given [task], returning the result of the visit. This method will
+   * throw an AnalysisException if the visitor throws an exception.
    */
   E visitPolymerBuildHtmlTask(PolymerBuildHtmlTask task);
 
   /**
-   * Visit a [PolymerResolveHtmlTask].
-   *
-   * @param task the task to be visited
-   * @return the result of visiting the task
-   * @throws AnalysisException if the visitor throws an exception for some reason
+   * Visit the given [task], returning the result of the visit. This method will
+   * throw an AnalysisException if the visitor throws an exception.
    */
   E visitPolymerResolveHtmlTask(PolymerResolveHtmlTask task);
 
   /**
-   * Visit a [ResolveAngularComponentTemplateTask].
-   *
-   * @param task the task to be visited
-   * @return the result of visiting the task
-   * @throws AnalysisException if the visitor throws an exception for some reason
+   * Visit the given [task], returning the result of the visit. This method will
+   * throw an AnalysisException if the visitor throws an exception.
    */
   E visitResolveAngularComponentTemplateTask(ResolveAngularComponentTemplateTask task);
 
   /**
-   * Visit a [ResolveAngularEntryHtmlTask].
-   *
-   * @param task the task to be visited
-   * @return the result of visiting the task
-   * @throws AnalysisException if the visitor throws an exception for some reason
+   * Visit the given [task], returning the result of the visit. This method will
+   * throw an AnalysisException if the visitor throws an exception.
    */
   E visitResolveAngularEntryHtmlTask(ResolveAngularEntryHtmlTask task);
 
   /**
-   * Visit a [ResolveDartLibraryCycleTask].
-   *
-   * @param task the task to be visited
-   * @return the result of visiting the task
-   * @throws AnalysisException if the visitor throws an exception for some reason
+   * Visit the given [task], returning the result of the visit. This method will
+   * throw an AnalysisException if the visitor throws an exception.
    */
   E visitResolveDartLibraryCycleTask(ResolveDartLibraryCycleTask task);
 
   /**
-   * Visit a [ResolveDartLibraryTask].
-   *
-   * @param task the task to be visited
-   * @return the result of visiting the task
-   * @throws AnalysisException if the visitor throws an exception for some reason
+   * Visit the given [task], returning the result of the visit. This method will
+   * throw an AnalysisException if the visitor throws an exception.
    */
   E visitResolveDartLibraryTask(ResolveDartLibraryTask task);
 
   /**
-   * Visit a [ResolveDartUnitTask].
-   *
-   * @param task the task to be visited
-   * @return the result of visiting the task
-   * @throws AnalysisException if the visitor throws an exception for some reason
+   * Visit the given [task], returning the result of the visit. This method will
+   * throw an AnalysisException if the visitor throws an exception.
    */
   E visitResolveDartUnitTask(ResolveDartUnitTask task);
 
   /**
-   * Visit a [ResolveHtmlTask].
-   *
-   * @param task the task to be visited
-   * @return the result of visiting the task
-   * @throws AnalysisException if the visitor throws an exception for some reason
+   * Visit the given [task], returning the result of the visit. This method will
+   * throw an AnalysisException if the visitor throws an exception.
    */
   E visitResolveHtmlTask(ResolveHtmlTask task);
 
   /**
-   * Visit a [ScanDartTask].
-   *
-   * @param task the task to be visited
-   * @return the result of visiting the task
-   * @throws AnalysisException if the visitor throws an exception for some reason
+   * Visit the given [task], returning the result of the visit. This method will
+   * throw an AnalysisException if the visitor throws an exception.
    */
   E visitScanDartTask(ScanDartTask task);
 }
 
 /**
  * An [Expression] with optional [AngularFormatterNode]s.
  */
 class AngularExpression {
   /**
    * The [Expression] to apply formatters to.
@@ skipping 1680 matching lines @@
       = new ResolutionState();
 
   /**
    * The data descriptor representing the errors reported during Angular
    * resolution.
    */
   static final DataDescriptor<List<AnalysisError>> ANGULAR_ERRORS
       = new DataDescriptor<List<AnalysisError>>("DartEntry.ANGULAR_ERRORS", AnalysisError.NO_ERRORS);
 
   /**
-   * The data descriptor representing the errors resulting from building the
-   * element model.
+   * The data descriptor representing the element model representing a single
+   * compilation unit. This model is incomplete and should not be used except as
+   * input to another task.
    */
-  static final DataDescriptor<List<AnalysisError>> BUILD_ELEMENT_ERRORS
-      = new DataDescriptor<List<AnalysisError>>("DartEntry.BUILD_ELEMENT_ERRORS", AnalysisError.NO_ERRORS);
+  static final DataDescriptor<List<AnalysisError>> BUILT_ELEMENT
+      = new DataDescriptor<List<AnalysisError>>("DartEntry.BUILT_ELEMENT");
 
   /**
    * The data descriptor representing the AST structure after the element model
    * has been built (and declarations are resolved) but before other resolution
    * has been performed.
    */
   static final DataDescriptor<CompilationUnit> BUILT_UNIT
       = new DataDescriptor<CompilationUnit>("DartEntry.BUILT_UNIT");
 
   /**
@@ skipping 137 matching lines @@
   /**
    * Return all of the errors associated with the compilation unit that are
    * currently cached.
    */
   List<AnalysisError> get allErrors {
     List<AnalysisError> errors = new List<AnalysisError>();
     errors.addAll(getValue(SCAN_ERRORS));
     errors.addAll(getValue(PARSE_ERRORS));
     ResolutionState state = _resolutionState;
     while (state != null) {
-      errors.addAll(state.getValue(BUILD_ELEMENT_ERRORS));
       errors.addAll(state.getValue(RESOLUTION_ERRORS));
       errors.addAll(state.getValue(VERIFICATION_ERRORS));
       errors.addAll(state.getValue(HINTS));
       state = state._nextState;
     }
     errors.addAll(getValue(ANGULAR_ERRORS));
     if (errors.length == 0) {
       return AnalysisError.NO_ERRORS;
     }
     return new List.from(errors);
@@ skipping 205 matching lines @@
       if (resolvedState != CacheState.VALID
           && resolvedState != CacheState.FLUSHED) {
         return false;
       }
       state = state._nextState;
     }
     return true;
   }
 
   /**
-   * Record that an error occurred while attempting to build the element model
-   * for the source represented by this entry. This will set the state of all
-   * resolution-based information as being in error, but will not change the
-   * state of any parse results.
-   *
-   * @param librarySource the source of the library in which the element model was being built
-   * @param exception the exception that shows where the error occurred
+   * Record that an [exception] occurred while attempting to build the element
+   * model for the source represented by this entry in the context of the given
+   * [library]. This will set the state of all resolution-based information as
+   * being in error, but will not change the state of any parse results.
    */
   void recordBuildElementErrorInLibrary(Source librarySource, CaughtException exception) {
-    this.exception = exception;
-    setState(ELEMENT, CacheState.ERROR);
-    setState(IS_LAUNCHABLE, CacheState.ERROR);
-    setState(IS_CLIENT, CacheState.ERROR);
-    ResolutionState state = _getOrCreateResolutionState(librarySource);
-    state.recordBuildElementError();
+    setStateInLibrary(BUILT_ELEMENT, librarySource, CacheState.ERROR);
+    setStateInLibrary(BUILT_UNIT, librarySource, CacheState.ERROR);
+    recordResolutionErrorInLibrary(librarySource, exception);
   }
 
   @override
   void recordContentError(CaughtException exception) {
     super.recordContentError(exception);
     recordScanError(exception);
   }
 
   /**
    * Record that an error occurred while attempting to generate hints for the
@@ skipping 328 matching lines @@
         || descriptor == SOURCE_KIND
         || descriptor == TOKEN_STREAM
         || super._isValidDescriptor(descriptor);
   }
 
   /**
    * Return `true` if the [descriptor] is valid for this entry when the data is
    * relative to a library.
    */
   bool _isValidLibraryDescriptor(DataDescriptor descriptor) {
-    return descriptor == BUILD_ELEMENT_ERRORS
+    return descriptor == BUILT_ELEMENT
         || descriptor == BUILT_UNIT
         || descriptor == HINTS
         || descriptor == RESOLUTION_ERRORS
         || descriptor == RESOLVED_UNIT
         || descriptor == VERIFICATION_ERRORS;
   }
 
   /**
    * Given that the specified flag is being transitioned to the given state, set the value of the
    * flag to the value that should be kept in the cache.
@@ skipping 3416 matching lines @@
     }
     return false;
   }
 
   /**
    * Invalidate all of the resolution information associated with the compilation unit.
    */
   void invalidateAllResolutionInformation() {
     _nextState = null;
     _librarySource = null;
-    setState(DartEntry.BUILT_UNIT, CacheState.INVALID);
-    setState(DartEntry.BUILD_ELEMENT_ERRORS, CacheState.INVALID);
     setState(DartEntry.RESOLVED_UNIT, CacheState.INVALID);
     setState(DartEntry.RESOLUTION_ERRORS, CacheState.INVALID);
     setState(DartEntry.VERIFICATION_ERRORS, CacheState.INVALID);
     setState(DartEntry.HINTS, CacheState.INVALID);
   }
 
   /**
-   * Record that an error occurred while attempting to build the element model for the source
-   * represented by this state.
+   * Record that an exception occurred while attempting to build the element
+   * model for the source associated with this state.
    */
   void recordBuildElementError() {
     setState(DartEntry.BUILT_UNIT, CacheState.ERROR);
-    setState(DartEntry.BUILD_ELEMENT_ERRORS, CacheState.ERROR);
+    setState(DartEntry.BUILT_ELEMENT, CacheState.ERROR);
     recordResolutionError();
   }
 
   /**
-   * Record that an error occurred while attempting to generate hints for the source represented
-   * by this entry. This will set the state of all verification information as being in error.
+   * Record that an exception occurred while attempting to generate hints for
+   * the source associated with this entry. This will set the state of all
+   * verification information as being in error.
    */
   void recordHintError() {
     setState(DartEntry.HINTS, CacheState.ERROR);
   }
 
   /**
-   * Record that an error occurred while attempting to resolve the source represented by this
-   * state.
+   * Record that an exception occurred while attempting to resolve the source
+   * associated with this state.
    */
   void recordResolutionError() {
     setState(DartEntry.RESOLVED_UNIT, CacheState.ERROR);
     setState(DartEntry.RESOLUTION_ERRORS, CacheState.ERROR);
     recordVerificationError();
   }
 
   /**
-   * Record that an error occurred while attempting to scan or parse the entry represented by this
-   * entry. This will set the state of all resolution-based information as being in error, but
-   * will not change the state of any parse results.
+   * Record that an exception occurred while attempting to scan or parse the
+   * source associated with this entry. This will set the state of all
+   * resolution-based information as being in error.
    */
   void recordResolutionErrorsInAllLibraries() {
     recordBuildElementError();
     if (_nextState != null) {
       _nextState.recordResolutionErrorsInAllLibraries();
     }
   }
 
   /**
-   * 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.
+   * Record that an exception occurred while attempting to generate errors and
+   * warnings for the source associated with this entry. This will set the state
+   * of all verification information as being in error.
    */
   void recordVerificationError() {
     setState(DartEntry.VERIFICATION_ERRORS, CacheState.ERROR);
     recordHintError();
   }
 
   /**
    * Set the state of the data represented by the given [descriptor] to the
    * given [state].
    */
@@ skipping 58 matching lines @@
   }
 
   /**
    * Write a textual representation of this state to the given builder. The result will only be
    * used for debugging purposes.
    *
    * @param builder the builder to which the text should be written
    */
   void _writeOn(StringBuffer buffer) {
     if (_librarySource != null) {
+      _writeStateOn(buffer, "builtElement", DartEntry.BUILT_ELEMENT);
       _writeStateOn(buffer, "builtUnit", DartEntry.BUILT_UNIT);
-      _writeStateOn(buffer, "buildElementErrors", DartEntry.BUILD_ELEMENT_ERRORS);
       _writeStateOn(buffer, "resolvedUnit", DartEntry.RESOLVED_UNIT);
       _writeStateOn(buffer, "resolutionErrors", DartEntry.RESOLUTION_ERRORS);
       _writeStateOn(buffer, "verificationErrors", DartEntry.VERIFICATION_ERRORS);
       _writeStateOn(buffer, "hints", DartEntry.HINTS);
       if (_nextState != null) {
         _nextState._writeOn(buffer);
       }
     }
   }
 
@@ skipping 1373 matching lines @@
     _index++;
     if (_index >= _manager._workQueues[_queueIndex].length) {
       _index = 0;
       _queueIndex++;
       while (_queueIndex < _manager._workQueues.length && _manager._workQueues[_queueIndex].isEmpty) {
         _queueIndex++;
       }
     }
   }
 }