Unify Entry and EntryImpl classes

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';
@@ skipping 133 matching lines @@
     return new MultipleMapIterator<Source, SourceEntry>(maps);
   }
 
   /**
    * Associate the given entry with the given source.
    *
    * @param source the source with which the entry is to be associated
    * @param entry the entry to be associated with the source
    */
   void put(Source source, SourceEntry entry) {
-    (entry as SourceEntryImpl).fixExceptionState();
+    entry.fixExceptionState();
     int count = _partitions.length;
     for (int i = 0; i < count; i++) {
       if (_partitions[i].contains(source)) {
         if (_TRACE_CHANGES) {
           try {
             SourceEntry oldEntry = _partitions[i].get(source);
             if (oldEntry == null) {
               AnalysisEngine.instance.logger.logInformation("Added a cache entry for '${source.fullName}'.");
             } else {
-              AnalysisEngine.instance.logger.logInformation("Modified the cache entry for ${source.fullName}'. Diff = ${(entry as SourceEntryImpl).getDiff(oldEntry)}");
+              AnalysisEngine.instance.logger.logInformation("Modified the cache entry for ${source.fullName}'. Diff = ${entry.getDiff(oldEntry)}");
             }
           } catch (exception) {
             // Ignored
             JavaSystem.currentTimeMillis();
           }
         }
         _partitions[i].put(source, entry);
         return;
       }
     }
@@ skipping 170 matching lines @@
    * @param source the source defining the HTML file whose element model is to be returned
    * @return the element model corresponding to the HTML file defined by the given source
    * @throws AnalysisException if the element model could not be determined because the analysis
    *           could not be performed
    * @see #getHtmlElement(Source)
    */
   HtmlElement computeHtmlElement(Source source);
 
   /**
    * Return the kind of the given source, computing it's kind if it is not already known. Return
-   * [SourceKind#UNKNOWN] if the source is not contained in this context.
+   * [SourceKind.UNKNOWN] if the source is not contained in this context.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source whose kind is to be returned
    * @return the kind of the given source
    * @see #getKindOf(Source)
    */
   SourceKind computeKindOf(Source source);
 
   /**
@@ skipping 29 matching lines @@
   LineInfo computeLineInfo(Source source);
 
   /**
    * Notifies the context that the client is going to stop using this context.
    */
   void dispose();
 
   /**
    * Return `true` if the given source exists.
    *
-   * This method should be used rather than the method [Source#exists] because contexts can
+   * This method should be used rather than the method [Source.exists] because contexts can
    * have local overrides of the content of a source that the source is not aware of and a source
    * with local content is considered to exist even if there is no file on disk.
    *
    * @param source the source whose modification stamp is to be returned
    * @return `true` if the source exists
    */
   bool exists(Source source);
 
   /**
    * Return the set of analysis options controlling the behavior of this context. Clients should not
@@ skipping 22 matching lines @@
    * @param unitSource the source of the compilation unit
    * @param librarySource the source of the defining compilation unit of the library containing the
    *          compilation unit
    * @return the element model corresponding to the compilation unit defined by the given source
    */
   CompilationUnitElement getCompilationUnitElement(Source unitSource, Source librarySource);
 
   /**
    * Get the contents and timestamp of the given source.
    *
-   * This method should be used rather than the method [Source#getContents] because contexts
+   * This method should be used rather than the method [Source.getContents] because contexts
    * can have local overrides of the content of a source that the source is not aware of.
    *
    * @param source the source whose content is to be returned
    * @return the contents and timestamp of the source
    * @throws Exception if the contents of the source could not be accessed
    */
   TimestampedData<String> getContents(Source source);
 
   /**
    * Return the set of declared variables used when computing constant values.
@@ skipping 149 matching lines @@
    */
   LineInfo getLineInfo(Source source);
 
   /**
    * Return the modification stamp for the given source. A modification stamp is a non-negative
    * integer with the property that if the contents of the source have not been modified since the
    * last time the modification stamp was accessed then the same value will be returned, but if the
    * contents of the source have been modified one or more times (even if the net change is zero)
    * the stamps will be different.
    *
-   * This method should be used rather than the method [Source#getModificationStamp] because
+   * This method should be used rather than the method [Source.getModificationStamp] because
    * contexts can have local overrides of the content of a source that the source is not aware of.
    *
    * @param source the source whose modification stamp is to be returned
    * @return the modification stamp for the source
    */
   int getModificationStamp(Source source);
 
   /**
    * Return an array containing all of the sources known to this context and their resolution state
    * is not valid or flush. So, these sources are not safe to update during refactoring, because we
@@ skipping 437 matching lines @@
         SourceEntry sourceEntry = iterator.value;
         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) {
-          (entry as DartEntryImpl).invalidateAllResolutionInformation(false);
+          entry.invalidateAllResolutionInformation(false);
           _workManager.add(source, _computePriority(entry));
         } else if (entry is HtmlEntry) {
-          (entry as HtmlEntryImpl).invalidateAllResolutionInformation(false);
+          entry.invalidateAllResolutionInformation(false);
           _workManager.add(source, SourcePriority.HTML);
         }
       }
     }
   }
 
   @override
   String computeDocumentationComment(Element element) {
     if (element == null) {
       return null;
@@ skipping 116 matching lines @@
         return _getDartScanData2(source, SourceEntry.LINE_INFO, null);
       }
     } on ObsoleteSourceAnalysisException catch (exception) {
       AnalysisEngine.instance.logger.logInformation2("Could not compute ${SourceEntry.LINE_INFO.toString()}", exception);
     }
     return null;
   }
 
   @override
   ResolvableCompilationUnit computeResolvableCompilationUnit(Source source) {
-    DartEntryImpl dartEntry = _getReadableDartEntry(source);
+    DartEntry dartEntry = _getReadableDartEntry(source);
     if (dartEntry == null) {
       throw new AnalysisException("computeResolvableCompilationUnit for non-Dart: ${source.fullName}");
     }
     dartEntry = _cacheDartParseData(source, dartEntry, DartEntry.PARSED_UNIT);
     CompilationUnit unit = dartEntry.resolvableCompilationUnit;
     if (unit == null) {
       throw new AnalysisException("Internal error: computeResolvableCompilationUnit could not parse ${source.fullName}", new CaughtException(dartEntry.exception, null));
     }
     return new ResolvableCompilationUnit.con1(dartEntry.modificationTime, unit);
   }
@@ skipping 276 matching lines @@
   }
 
   @override
   List<Source> get prioritySources => _priorityOrder;
 
   @override
   Namespace getPublicNamespace(LibraryElement library) {
     // TODO(brianwilkerson) Rename this to not start with 'get'. Note that this is not part of the
     // API of the interface.
     Source source = library.definingCompilationUnit.source;
-    DartEntryImpl dartEntry = _getReadableDartEntry(source);
+    DartEntry dartEntry = _getReadableDartEntry(source);
     if (dartEntry == null) {
       return null;
     }
     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);
@@ skipping 226 matching lines @@
 
   @override
   void recordLibraryElements(Map<Source, LibraryElement> elementMap) {
     Source htmlSource = _sourceFactory.forUri(DartSdk.DART_HTML);
     for (MapEntry<Source, LibraryElement> entry in getMapEntrySet(elementMap)) {
       Source librarySource = entry.getKey();
       LibraryElement library = entry.getValue();
       //
       // Cache the element in the library's info.
       //
-      DartEntryImpl dartEntry = _getReadableDartEntry(librarySource);
+      DartEntry dartEntry = _getReadableDartEntry(librarySource);
       if (dartEntry != null) {
         _recordElementData(dartEntry, library, library.source, htmlSource);
         dartEntry.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
         dartEntry.setValue(SourceEntry.LINE_INFO, new LineInfo(<int> [0]));
         dartEntry.setValue(DartEntry.ANGULAR_ERRORS, AnalysisError.NO_ERRORS);
         // DartEntry.ELEMENT - set in recordElementData
         dartEntry.setValue(DartEntry.EXPORTED_LIBRARIES, Source.EMPTY_ARRAY);
         dartEntry.setValue(DartEntry.IMPORTED_LIBRARIES, Source.EMPTY_ARRAY);
         dartEntry.setValue(DartEntry.INCLUDED_PARTS, Source.EMPTY_ARRAY);
         // DartEntry.IS_CLIENT - set in recordElementData
@@ skipping 96 matching lines @@
 
   @override
   void setChangedContents(Source source, String contents, int offset, int oldLength, int newLength) {
     String originalContents = _contentCache.setContents(source, contents);
     if (contents != null) {
       if (contents != originalContents) {
         if (_options.incremental) {
           _incrementalAnalysisCache = IncrementalAnalysisCache.update(_incrementalAnalysisCache, source, originalContents, contents, offset, oldLength, newLength, _getReadableSourceEntry(source));
         }
         _sourceChanged(source);
-        SourceEntryImpl sourceEntry = _cache.get(source);
+        SourceEntry sourceEntry = _cache.get(source);
         if (sourceEntry != null) {
           sourceEntry.modificationTime = _contentCache.getModificationStamp(source);
           sourceEntry.setValue(SourceEntry.CONTENT, contents);
         }
       }
     } else if (originalContents != null) {
       _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
       _sourceChanged(source);
     }
   }
 
   @override
   void setContents(Source source, String contents) {
     String originalContents = _contentCache.setContents(source, contents);
     if (contents != null) {
       if (contents != originalContents) {
         _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
         _sourceChanged(source);
-        SourceEntryImpl sourceEntry = _cache.get(source);
+        SourceEntry sourceEntry = _cache.get(source);
         if (sourceEntry != null) {
           sourceEntry.modificationTime = _contentCache.getModificationStamp(source);
           sourceEntry.setValue(SourceEntry.CONTENT, contents);
         }
       }
     } else if (originalContents != null) {
       _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
       _sourceChanged(source);
     }
   }
@@ skipping 38 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;
     CaughtException thrownException = task.exception;
-    DartEntryImpl unitEntry = null;
+    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.
@@ skipping 15 matching lines @@
       }
       if (_allModificationTimesMatch(resolvedLibraries)) {
         Source htmlSource = sourceFactory.forUri(DartSdk.DART_HTML);
         RecordingErrorListener errorListener = resolver.errorListener;
         for (ResolvableLibrary library in resolvedLibraries) {
           Source librarySource = library.librarySource;
           for (Source source in library.compilationUnitSources) {
             CompilationUnit unit = library.getAST(source);
             List<AnalysisError> errors = errorListener.getErrorsForSource(source);
             LineInfo lineInfo = getLineInfo(source);
-            DartEntryImpl dartEntry = _cache.get(source);
+            DartEntry dartEntry = _cache.get(source);
             if (thrownException == null) {
               dartEntry.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED);
               dartEntry.setValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource, unit);
               dartEntry.setValueInLibrary(DartEntry.RESOLUTION_ERRORS, librarySource, errors);
               if (source == librarySource) {
                 _recordElementData(dartEntry, library.libraryElement, librarySource, htmlSource);
               }
               _cache.storedAst(source);
             } else {
               dartEntry.recordResolutionErrorInLibrary(librarySource, thrownException);
               _cache.remove(source);
             }
             if (source != librarySource) {
               _workManager.add(source, SourcePriority.PRIORITY_PART);
             }
             if (source == unitSource) {
               unitEntry = dartEntry;
             }
             ChangeNoticeImpl notice = _getNotice(source);
             notice.compilationUnit = unit;
             notice.setErrors(dartEntry.allErrors, lineInfo);
           }
         }
       } else {
         PrintStringWriter writer = new PrintStringWriter();
         writer.println("Library resolution results discarded for");
         for (ResolvableLibrary library in resolvedLibraries) {
           for (Source source in library.compilationUnitSources) {
-            DartEntryImpl dartEntry = _getReadableDartEntry(source);
+            DartEntry dartEntry = _getReadableDartEntry(source);
             if (dartEntry != null) {
               int resultTime = library.getModificationTime(source);
               writer.println("  ${_debuggingString(source)}; sourceTime = ${getModificationStamp(source)}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}");
               if (thrownException == null || resultTime >= 0) {
                 //
                 // The analysis was performed on out-of-date sources. Mark the cache so that the
                 // sources will be re-analyzed using the up-to-date sources.
                 //
                 dartEntry.recordResolutionNotInProcess();
               } else {
@@ skipping 24 matching lines @@
       if (unitEntry == null) {
         throw new AnalysisException("A Dart file became a non-Dart file: ${unitSource.fullName}");
       }
     }
     return unitEntry;
   }
 
   DartEntry recordResolveDartLibraryTaskResults(ResolveDartLibraryTask task) {
     LibraryResolver resolver = task.libraryResolver;
     CaughtException thrownException = task.exception;
-    DartEntryImpl unitEntry = null;
+    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.
@@ skipping 15 matching lines @@
       }
       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);
-            DartEntryImpl dartEntry = _cache.get(source);
+            DartEntry dartEntry = _cache.get(source);
             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("A Dart file became a non-Dart file: ${source.fullName}");
               }
             }
             if (thrownException == null) {
@@ skipping 18 matching lines @@
             ChangeNoticeImpl notice = _getNotice(source);
             notice.compilationUnit = unit;
             notice.setErrors(dartEntry.allErrors, lineInfo);
           }
         }
       } else {
         PrintStringWriter writer = new PrintStringWriter();
         writer.println("Library resolution results discarded for");
         for (Library library in resolvedLibraries) {
           for (Source source in library.compilationUnitSources) {
-            DartEntryImpl dartEntry = _getReadableDartEntry(source);
+            DartEntry dartEntry = _getReadableDartEntry(source);
             if (dartEntry != null) {
               int resultTime = library.getModificationTime(source);
               writer.println("  ${_debuggingString(source)}; sourceTime = ${getModificationStamp(source)}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}");
               if (thrownException == null || resultTime >= 0) {
                 //
                 // The analysis was performed on out-of-date sources. Mark the cache so that the
                 // sources will be re-analyzed using the up-to-date sources.
                 //
                 dartEntry.recordResolutionNotInProcess();
               } else {
@@ skipping 113 matching lines @@
           _sourceChanged(source);
           allTimesMatch = false;
         }
       }
     }
     return allTimesMatch;
   }
 
   /**
    * 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
+   * 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 generating hints
    * for the library if the data is not already cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param unitSource the source representing the Dart file
    * @param librarySource the source representing the library containing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
@@ skipping 28 matching lines @@
         }
       }
       dartEntry = new GenerateDartHintsTask(this, units, getLibraryElement(librarySource)).perform(_resultRecorder) as DartEntry;
       state = dartEntry.getStateInLibrary(descriptor, librarySource);
     }
     return dartEntry;
   }
 
   /**
    * Given a source for a Dart 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
+   * by the given descriptor is either [CacheState.VALID] or [CacheState.ERROR]. This
    * method assumes that the data can be produced by parsing the source if it is not already cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be parsed
    */
@@ skipping 14 matching lines @@
       //
       dartEntry = _cacheDartScanData(source, dartEntry, DartEntry.TOKEN_STREAM);
       dartEntry = new ParseDartTask(this, source, dartEntry.modificationTime, dartEntry.getValue(DartEntry.TOKEN_STREAM), dartEntry.getValue(SourceEntry.LINE_INFO)).perform(_resultRecorder) as DartEntry;
       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 resolving the
+   * 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
    * source in the context of the library if it is not already cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param unitSource the source representing the Dart file
    * @param librarySource the source representing the library containing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be parsed
@@ skipping 11 matching lines @@
       // TODO(brianwilkerson) As an optimization, if we already have the element model for the
       // library we can use ResolveDartUnitTask to produce the resolved AST structure much faster.
       dartEntry = new ResolveDartLibraryTask(this, unitSource, librarySource).perform(_resultRecorder) as DartEntry;
       state = (identical(descriptor, DartEntry.ELEMENT)) ? dartEntry.getState(descriptor) : dartEntry.getStateInLibrary(descriptor, librarySource);
     }
     return dartEntry;
   }
 
   /**
    * Given a source for a Dart 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
+   * by the given descriptor is either [CacheState.VALID] or [CacheState.ERROR]. This
    * method assumes that the data can be produced by scanning the source if it is not already
    * cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be scanned
@@ skipping 18 matching lines @@
       } 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
+   * 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
    * source in the given library if the data is not already cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param unitSource the source representing the Dart file
    * @param librarySource the source representing the library containing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be parsed
@@ skipping 14 matching lines @@
         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
-   * [CacheState#ERROR]. This method assumes that the data can be produced by parsing the
+   * the state of the given descriptors is either [CacheState.VALID] or
+   * [CacheState.ERROR]. This method assumes that the data can be produced by parsing the
    * source if it is not already cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the HTML file
    * @param htmlEntry the cache entry associated with the HTML file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
@@ skipping 24 matching lines @@
       } 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
+   * represented by the given descriptor is either [CacheState.VALID] or
+   * [CacheState.ERROR]. This method assumes that the data can be produced by resolving the
    * source if it is not already cached.
    *
    * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source representing the HTML file
    * @param dartEntry the cache entry associated with the HTML file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
@@ skipping 91 matching lines @@
    * 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, DartEntryImpl unitEntry, Source librarySource, DartEntry libraryEntry) {
+  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) {
       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);
       unitEntry.recordResolutionError(exception);
       return new AnalysisContextImpl_TaskData(null, false);
     }
     LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
     unitEntry.setStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.IN_PROCESS);
     return new AnalysisContextImpl_TaskData(new GenerateDartErrorsTask(this, unitSource, unitEntry.modificationTime, unit, libraryElement), false);
   }
 
   /**
    * Create a [GenerateDartHintsTask] for the given source, marking the hints as being
    * in-process.
    *
    * @param source the source whose content is to be verified
    * @param dartEntry the entry for the source
    * @param librarySource the source for the library containing the source
    * @param libraryEntry the entry for the library
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData _createGenerateDartHintsTask(Source source, DartEntryImpl dartEntry, Source librarySource, DartEntry libraryEntry) {
+  AnalysisContextImpl_TaskData _createGenerateDartHintsTask(Source source, DartEntry dartEntry, Source librarySource, DartEntry libraryEntry) {
     if (libraryEntry.getState(DartEntry.ELEMENT) != CacheState.VALID) {
       return _createResolveDartLibraryTask(librarySource, libraryEntry);
     }
     LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
     CompilationUnitElement definingUnit = libraryElement.definingCompilationUnit;
     List<CompilationUnitElement> parts = libraryElement.parts;
     List<TimestampedData<CompilationUnit>> units = new List<TimestampedData>(parts.length + 1);
     units[0] = _getResolvedUnit(definingUnit, librarySource);
     if (units[0] == null) {
       // TODO(brianwilkerson) We should return a ResolveDartUnitTask (unless there are multiple ASTs
@@ skipping 12 matching lines @@
     return new AnalysisContextImpl_TaskData(new GenerateDartHintsTask(this, units, libraryElement), false);
   }
 
   /**
    * Create a [GetContentTask] for the given source, marking the content as being in-process.
    *
    * @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, SourceEntryImpl sourceEntry) {
+  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
    */
-  AnalysisContextImpl_TaskData _createParseDartTask(Source source, DartEntryImpl dartEntry) {
+  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, dartEntry.modificationTime, 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
    */
-  AnalysisContextImpl_TaskData _createParseHtmlTask(Source source, HtmlEntryImpl htmlEntry) {
+  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, htmlEntry.modificationTime, content), false);
   }
 
   /**
    * Create a [PolymerBuildHtmlTask] for the given source, marking the Polymer elements as
    * being in-process.
    *
    * @param source the source whose content is to be processed
    * @param htmlEntry the entry for the source
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData _createPolymerBuildHtmlTask(Source source, HtmlEntryImpl htmlEntry) {
+  AnalysisContextImpl_TaskData _createPolymerBuildHtmlTask(Source source, HtmlEntry htmlEntry) {
     if (htmlEntry.getState(HtmlEntry.RESOLVED_UNIT) != CacheState.VALID) {
       return _createResolveHtmlTask(source, htmlEntry);
     }
     htmlEntry.setState(HtmlEntry.POLYMER_BUILD_ERRORS, CacheState.IN_PROCESS);
     return new AnalysisContextImpl_TaskData(new PolymerBuildHtmlTask(this, source, htmlEntry.modificationTime, htmlEntry.getValue(SourceEntry.LINE_INFO), htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT)), false);
   }
 
   /**
    * Create a [PolymerResolveHtmlTask] for the given source, marking the Polymer errors as
    * being in-process.
    *
    * @param source the source whose content is to be resolved
    * @param htmlEntry the entry for the source
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData _createPolymerResolveHtmlTask(Source source, HtmlEntryImpl htmlEntry) {
+  AnalysisContextImpl_TaskData _createPolymerResolveHtmlTask(Source source, HtmlEntry htmlEntry) {
     if (htmlEntry.getState(HtmlEntry.RESOLVED_UNIT) != CacheState.VALID) {
       return _createResolveHtmlTask(source, htmlEntry);
     }
     htmlEntry.setState(HtmlEntry.POLYMER_RESOLUTION_ERRORS, CacheState.IN_PROCESS);
     return new AnalysisContextImpl_TaskData(new PolymerResolveHtmlTask(this, source, htmlEntry.modificationTime, htmlEntry.getValue(SourceEntry.LINE_INFO), htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT)), false);
   }
 
   /**
    * Create a [ResolveAngularComponentTemplateTask] for the given source, marking the angular
    * errors as being in-process.
    *
    * @param source the source whose content is to be resolved
    * @param htmlEntry the entry for the source
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData _createResolveAngularComponentTemplateTask(Source source, HtmlEntryImpl htmlEntry) {
+  AnalysisContextImpl_TaskData _createResolveAngularComponentTemplateTask(Source source, HtmlEntry htmlEntry) {
     if (htmlEntry.getState(HtmlEntry.RESOLVED_UNIT) != CacheState.VALID) {
       return _createResolveHtmlTask(source, htmlEntry);
     }
     AngularApplication application = htmlEntry.getValue(HtmlEntry.ANGULAR_APPLICATION);
     AngularComponentElement component = htmlEntry.getValue(HtmlEntry.ANGULAR_COMPONENT);
     htmlEntry.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.IN_PROCESS);
     return new AnalysisContextImpl_TaskData(new ResolveAngularComponentTemplateTask(this, source, htmlEntry.modificationTime, htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT), component, application), false);
   }
 
   /**
    * Create a [ResolveAngularEntryHtmlTask] for the given source, marking the angular entry as
    * being in-process.
    *
    * @param source the source whose content is to be resolved
    * @param htmlEntry the entry for the source
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData _createResolveAngularEntryHtmlTask(Source source, HtmlEntryImpl htmlEntry) {
+  AnalysisContextImpl_TaskData _createResolveAngularEntryHtmlTask(Source source, HtmlEntry htmlEntry) {
     if (htmlEntry.getState(HtmlEntry.RESOLVED_UNIT) != CacheState.VALID) {
       return _createResolveHtmlTask(source, htmlEntry);
     }
     htmlEntry.setState(HtmlEntry.ANGULAR_ENTRY, CacheState.IN_PROCESS);
     return new AnalysisContextImpl_TaskData(new ResolveAngularEntryHtmlTask(this, source, htmlEntry.modificationTime, htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT)), false);
   }
 
   /**
    * Create a [ResolveDartLibraryTask] for the given source, marking ? as being in-process.
    *
    * @param source the source whose content is to be resolved
    * @param dartEntry the entry for the source
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData _createResolveDartLibraryTask(Source source, DartEntryImpl dartEntry) {
+  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, stackTrace) {
       dartEntry.recordResolutionError(new CaughtException(exception, stackTrace));
       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
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData _createResolveHtmlTask(Source source, HtmlEntryImpl htmlEntry) {
+  AnalysisContextImpl_TaskData _createResolveHtmlTask(Source source, HtmlEntry htmlEntry) {
     if (htmlEntry.getState(HtmlEntry.PARSED_UNIT) != CacheState.VALID) {
       return _createParseHtmlTask(source, htmlEntry);
     }
     htmlEntry.setState(HtmlEntry.RESOLVED_UNIT, CacheState.IN_PROCESS);
     return new AnalysisContextImpl_TaskData(new ResolveHtmlTask(this, source, htmlEntry.modificationTime, htmlEntry.getValue(HtmlEntry.PARSED_UNIT)), false);
   }
 
   /**
    * Create a [ScanDartTask] for the given source, marking the scan errors as being
    * in-process.
    *
    * @param source the source whose content is to be scanned
    * @param dartEntry the entry for the source
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData _createScanDartTask(Source source, DartEntryImpl dartEntry) {
+  AnalysisContextImpl_TaskData _createScanDartTask(Source source, DartEntry dartEntry) {
     if (dartEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) {
       return _createGetContentTask(source, dartEntry);
     }
     String content = dartEntry.getValue(SourceEntry.CONTENT);
     dartEntry.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
     dartEntry.setState(DartEntry.SCAN_ERRORS, CacheState.IN_PROCESS);
     return new AnalysisContextImpl_TaskData(new ScanDartTask(this, source, dartEntry.modificationTime, content), false);
   }
 
   /**
    * Create a source information object suitable for the given source. Return the source information
    * object that was created, or `null` if the source should not be tracked by this context.
    *
    * @param source the source for which an information object is being created
    * @param explicitlyAdded `true` if the source was explicitly added to the context
    * @return the source information object that was created
    */
   SourceEntry _createSourceEntry(Source source, bool explicitlyAdded) {
     String name = source.shortName;
     if (AnalysisEngine.isHtmlFileName(name)) {
-      HtmlEntryImpl htmlEntry = new HtmlEntryImpl();
+      HtmlEntry htmlEntry = new HtmlEntry();
       htmlEntry.modificationTime = getModificationStamp(source);
       htmlEntry.explicitlyAdded = explicitlyAdded;
       _cache.put(source, htmlEntry);
       return htmlEntry;
     } else {
-      DartEntryImpl dartEntry = new DartEntryImpl();
+      DartEntry dartEntry = new DartEntry();
       dartEntry.modificationTime = getModificationStamp(source);
       dartEntry.explicitlyAdded = explicitlyAdded;
       _cache.put(source, dartEntry);
       return dartEntry;
     }
   }
 
   /**
    * Return a string with debugging information about the given source (the full name and
    * modification stamp of the source).
@@ skipping 404 matching lines @@
       return _createGetContentTask(source, sourceEntry);
     } else if (contentState == CacheState.IN_PROCESS) {
       // We are already in the process of getting the content. There's nothing else we can do with
       // this source until that's complete.
       return new AnalysisContextImpl_TaskData(null, true);
     } else if (contentState == CacheState.ERROR) {
       // We have done all of the analysis we can for this source because we cannot get its content.
       return new AnalysisContextImpl_TaskData(null, false);
     }
     if (sourceEntry is DartEntry) {
-      DartEntryImpl dartEntry = sourceEntry;
+      DartEntry dartEntry = sourceEntry;
       CacheState scanErrorsState = dartEntry.getState(DartEntry.SCAN_ERRORS);
       if (scanErrorsState == CacheState.INVALID || (isPriority && scanErrorsState == CacheState.FLUSHED)) {
         return _createScanDartTask(source, dartEntry);
       }
       CacheState parseErrorsState = dartEntry.getState(DartEntry.PARSE_ERRORS);
       if (parseErrorsState == CacheState.INVALID || (isPriority && parseErrorsState == CacheState.FLUSHED)) {
         return _createParseDartTask(source, dartEntry);
       }
       if (isPriority && parseErrorsState != CacheState.ERROR) {
         if (!dartEntry.hasResolvableCompilationUnit) {
           return _createParseDartTask(source, dartEntry);
         }
       }
       SourceKind kind = dartEntry.getValue(DartEntry.SOURCE_KIND);
       if (kind == SourceKind.UNKNOWN) {
         return _createParseDartTask(source, dartEntry);
       } else if (kind == SourceKind.LIBRARY) {
         CacheState elementState = dartEntry.getState(DartEntry.ELEMENT);
         if (elementState == CacheState.INVALID) {
           return _createResolveDartLibraryTask(source, dartEntry);
         }
       }
       List<Source> librariesContaining = dartEntry.getValue(DartEntry.CONTAINING_LIBRARIES);
       for (Source librarySource in librariesContaining) {
         SourceEntry librarySourceEntry = _cache.get(librarySource);
         if (librarySourceEntry is DartEntry) {
-          DartEntryImpl libraryEntry = librarySourceEntry;
+          DartEntry libraryEntry = librarySourceEntry;
           CacheState elementState = libraryEntry.getState(DartEntry.ELEMENT);
           if (elementState == CacheState.INVALID || (isPriority && elementState == CacheState.FLUSHED)) {
             //return createResolveDartLibraryTask(librarySource, (DartEntry) libraryEntry);
             libraryEntry.setState(DartEntry.ELEMENT, CacheState.IN_PROCESS);
             return new AnalysisContextImpl_TaskData(new ResolveDartLibraryTask(this, source, librarySource), false);
           }
           CacheState resolvedUnitState = dartEntry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource);
           if (resolvedUnitState == CacheState.INVALID || (isPriority && resolvedUnitState == CacheState.FLUSHED)) {
             //
             // The commented out lines below are an optimization that doesn't quite work yet. The
@@ skipping 309 matching lines @@
    * @param invalidateUris `true` if the cached results of converting URIs to source files
    *          should also be invalidated.
    */
   void _invalidateAllLocalResolutionInformation(bool invalidateUris) {
     HashMap<Source, List<Source>> oldPartMap = new HashMap<Source, List<Source>>();
     MapIterator<Source, SourceEntry> iterator = _privatePartition.iterator();
     while (iterator.moveNext()) {
       Source source = iterator.key;
       SourceEntry sourceEntry = iterator.value;
       if (sourceEntry is HtmlEntry) {
-        HtmlEntryImpl htmlEntry = sourceEntry;
+        HtmlEntry htmlEntry = sourceEntry;
         htmlEntry.invalidateAllResolutionInformation(invalidateUris);
         iterator.value = htmlEntry;
         _workManager.add(source, SourcePriority.HTML);
       } else if (sourceEntry is DartEntry) {
-        DartEntryImpl dartEntry = sourceEntry;
+        DartEntry dartEntry = sourceEntry;
         oldPartMap[source] = dartEntry.getValue(DartEntry.INCLUDED_PARTS);
         dartEntry.invalidateAllResolutionInformation(invalidateUris);
         iterator.value = dartEntry;
         _workManager.add(source, _computePriority(dartEntry));
       }
     }
     _removeFromPartsUsingMap(oldPartMap);
   }
 
   /**
    * In response to a change to Angular entry point [HtmlElement], invalidate any results that
    * depend on it.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * <b>Note:</b> Any cache entries that were accessed before this method was invoked must be
    * re-accessed after this method returns.
    *
-   * @param entryCopy the [HtmlEntryImpl] of the (maybe) Angular entry point being invalidated
+   * @param entryCopy the [HtmlEntry] of the (maybe) Angular entry point being invalidated
    */
-  void _invalidateAngularResolution(HtmlEntryImpl entryCopy) {
+  void _invalidateAngularResolution(HtmlEntry entryCopy) {
     AngularApplication application = entryCopy.getValue(HtmlEntry.ANGULAR_ENTRY);
     if (application == null) {
       return;
     }
     _angularApplications.remove(application);
     // invalidate Entry
     entryCopy.setState(HtmlEntry.ANGULAR_ENTRY, CacheState.INVALID);
     // reset HTML sources
     List<AngularElement> oldAngularElements = application.elements;
     for (AngularElement angularElement in oldAngularElements) {
       if (angularElement is AngularHasTemplateElement) {
         AngularHasTemplateElement hasTemplate = angularElement;
         Source templateSource = hasTemplate.templateSource;
         if (templateSource != null) {
-          HtmlEntryImpl htmlEntry = _getReadableHtmlEntry(templateSource);
+          HtmlEntry htmlEntry = _getReadableHtmlEntry(templateSource);
           htmlEntry.setValue(HtmlEntry.ANGULAR_APPLICATION, null);
           htmlEntry.setValue(HtmlEntry.ANGULAR_COMPONENT, null);
           htmlEntry.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.INVALID);
           _workManager.add(templateSource, SourcePriority.HTML);
         }
       }
     }
     // reset Dart sources
     List<Source> oldElementSources = application.elementSources;
     for (Source elementSource in oldElementSources) {
-      DartEntryImpl dartEntry = _getReadableDartEntry(elementSource);
+      DartEntry dartEntry = _getReadableDartEntry(elementSource);
       dartEntry.setValue(DartEntry.ANGULAR_ERRORS, AnalysisError.NO_ERRORS);
       // notify about (disappeared) Angular errors
       ChangeNoticeImpl notice = _getNotice(elementSource);
       notice.setErrors(dartEntry.allErrors, dartEntry.getValue(SourceEntry.LINE_INFO));
     }
   }
 
   /**
    * In response to a change to at least one of the compilation units in the given library,
    * invalidate any results that are dependent on the result of resolving that library.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * <b>Note:</b> Any cache entries that were accessed before this method was invoked must be
    * re-accessed after this method returns.
    *
    * @param librarySource the source of the library being invalidated
    */
   void _invalidateLibraryResolution(Source librarySource) {
     // TODO(brianwilkerson) This could be optimized. There's no need to flush all of these entries
     // if the public namespace hasn't changed, which will be a fairly common case. The question is
     // whether we can afford the time to compute the namespace to look for differences.
-    DartEntryImpl libraryEntry = _getReadableDartEntry(librarySource);
+    DartEntry libraryEntry = _getReadableDartEntry(librarySource);
     if (libraryEntry != null) {
       List<Source> includedParts = libraryEntry.getValue(DartEntry.INCLUDED_PARTS);
       libraryEntry.invalidateAllResolutionInformation(false);
       _workManager.add(librarySource, SourcePriority.LIBRARY);
       for (Source partSource in includedParts) {
         SourceEntry partEntry = _cache.get(partSource);
         if (partEntry is DartEntry) {
-          (partEntry as DartEntryImpl).invalidateAllResolutionInformation(false);
+          partEntry.invalidateAllResolutionInformation(false);
         }
       }
     }
     // invalidate Angular applications
     List<AngularApplication> angularApplicationsCopy = [];
     for (AngularApplication application in angularApplicationsCopy) {
       if (application.dependsOn(librarySource)) {
         Source entryPointSource = application.entryPoint;
-        HtmlEntryImpl htmlEntry = _getReadableHtmlEntry(entryPointSource);
+        HtmlEntry htmlEntry = _getReadableHtmlEntry(entryPointSource);
         _invalidateAngularResolution(htmlEntry);
         _workManager.add(entryPointSource, SourcePriority.HTML);
       }
     }
   }
 
   /**
    * Return `true` if this library is, or depends on, dart:html.
    *
    * @param library the library being tested
@@ skipping 149 matching lines @@
     int count = _listeners.length;
     for (int i = 0; i < count; i++) {
       _listeners[i].resolvedHtml(this, source, unit);
     }
   }
 
   /**
    * Updates [HtmlEntry]s that correspond to the previously known and new Angular application
    * information.
    */
-  void _recordAngularEntryPoint(HtmlEntryImpl entry, ResolveAngularEntryHtmlTask task) {
+  void _recordAngularEntryPoint(HtmlEntry entry, ResolveAngularEntryHtmlTask task) {
     AngularApplication application = task.application;
     if (application != null) {
       _angularApplications.add(application);
       // if this is an entry point, then we already resolved it
       entry.setValue(HtmlEntry.ANGULAR_ERRORS, task.entryErrors);
       // schedule HTML templates analysis
       List<AngularElement> newAngularElements = application.elements;
       for (AngularElement angularElement in newAngularElements) {
         if (angularElement is AngularHasTemplateElement) {
           AngularHasTemplateElement hasTemplate = angularElement;
           Source templateSource = hasTemplate.templateSource;
           if (templateSource != null) {
-            HtmlEntryImpl htmlEntry = _getReadableHtmlEntry(templateSource);
+            HtmlEntry htmlEntry = _getReadableHtmlEntry(templateSource);
             htmlEntry.setValue(HtmlEntry.ANGULAR_APPLICATION, application);
             if (hasTemplate is AngularComponentElement) {
               AngularComponentElement component = hasTemplate;
               htmlEntry.setValue(HtmlEntry.ANGULAR_COMPONENT, component);
             }
             htmlEntry.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.INVALID);
             _workManager.add(templateSource, SourcePriority.HTML);
           }
         }
       }
       // update Dart sources errors
       List<Source> newElementSources = application.elementSources;
       for (Source elementSource in newElementSources) {
-        DartEntryImpl dartEntry = _getReadableDartEntry(elementSource);
+        DartEntry dartEntry = _getReadableDartEntry(elementSource);
         dartEntry.setValue(DartEntry.ANGULAR_ERRORS, task.getErrors(elementSource));
         // notify about Dart errors
         ChangeNoticeImpl notice = _getNotice(elementSource);
         notice.setErrors(dartEntry.allErrors, computeLineInfo(elementSource));
       }
     }
     // remember Angular entry point
     entry.setValue(HtmlEntry.ANGULAR_ENTRY, application);
   }
 
   /**
    * 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(DartEntryImpl dartEntry, LibraryElement library, Source librarySource, Source htmlSource) {
+  void _recordElementData(DartEntry dartEntry, LibraryElement library, Source librarySource, Source htmlSource) {
     dartEntry.setValue(DartEntry.ELEMENT, library);
     dartEntry.setValue(DartEntry.IS_LAUNCHABLE, library.entryPoint != null);
     dartEntry.setValue(DartEntry.IS_CLIENT, _isClient(library, htmlSource, new HashSet<LibraryElement>()));
   }
 
   /**
    * 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;
     CaughtException thrownException = task.exception;
-    DartEntryImpl 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("Internal error: attempting to verify non-Dart file as a Dart file: ${source.fullName}");
     }
-    dartEntry = sourceEntry as DartEntry;
+    DartEntry dartEntry = sourceEntry;
     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("A Dart file became a non-Dart file: ${source.fullName}");
         }
@@ skipping 53 matching lines @@
       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("Internal error: attempting to generate hints for non-Dart file as a Dart file: ${librarySource.fullName}");
       }
       if (thrownException == null) {
         thrownException = new CaughtException(new AnalysisException("GenerateDartHintsTask returned a null hint map without throwing an exception: ${librarySource.fullName}"), null);
       }
-      (sourceEntry as DartEntryImpl).recordHintErrorInLibrary(librarySource, thrownException);
+      (sourceEntry as DartEntry).recordHintErrorInLibrary(librarySource, thrownException);
       throw new AnalysisException('<rethrow>', 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("Internal error: attempting to parse non-Dart file as a Dart file: ${unitSource.fullName}");
       }
-      DartEntryImpl dartEntry = sourceEntry;
+      DartEntry dartEntry = sourceEntry;
       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);
@@ skipping 45 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;
     CaughtException thrownException = task.exception;
-    SourceEntryImpl sourceEntry = null;
-    sourceEntry = _cache.get(source);
+    SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       throw new ObsoleteSourceAnalysisException(source);
     }
     if (thrownException == null) {
       sourceEntry.modificationTime = task.modificationTime;
       sourceEntry.setValue(SourceEntry.CONTENT, task.content);
     } else {
       sourceEntry.recordContentError(thrownException);
       _workManager.remove(source);
     }
@@ skipping 24 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;
     CaughtException thrownException = task.exception;
-    DartEntryImpl 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("Internal error: attempting to parse non-Dart file as a Dart file: ${source.fullName}");
     }
-    dartEntry = sourceEntry as DartEntry;
+    DartEntry 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("A Dart file became a non-Dart file: ${source.fullName}");
         }
@@ skipping 17 matching lines @@
             _workManager.add(source, SourcePriority.NORMAL_PART);
           } else {
             dartEntry.setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY);
             dartEntry.containingLibrary = source;
             _workManager.add(source, SourcePriority.LIBRARY);
           }
         }
         List<Source> newParts = task.includedSources;
         for (int i = 0; i < newParts.length; i++) {
           Source partSource = newParts[i];
-          DartEntryImpl partEntry = _getReadableDartEntry(partSource);
+          DartEntry partEntry = _getReadableDartEntry(partSource);
           if (partEntry != null && !identical(partEntry, dartEntry)) {
             // TODO(brianwilkerson) Change the kind of the "part" if it was marked as a library
             // and it has no directives.
             partEntry.addContainingLibrary(source);
           }
         }
         dartEntry.setValue(DartEntry.PARSED_UNIT, task.compilationUnit);
         dartEntry.setValue(DartEntry.PARSE_ERRORS, task.errors);
         dartEntry.setValue(DartEntry.EXPORTED_LIBRARIES, task.exportedSources);
         dartEntry.setValue(DartEntry.IMPORTED_LIBRARIES, task.importedSources);
@@ skipping 49 matching lines @@
     Source source = task.source;
     CaughtException thrownException = task.exception;
     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("Internal error: attempting to parse non-HTML file as a HTML file: ${source.fullName}");
     }
-    HtmlEntryImpl htmlEntry = sourceEntry;
+    HtmlEntry htmlEntry = sourceEntry;
     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("An HTML file became a non-HTML file: ${source.fullName}");
         }
@@ skipping 57 matching lines @@
     Source source = task.source;
     CaughtException thrownException = task.exception;
     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("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
     }
-    HtmlEntryImpl htmlEntry = sourceEntry;
+    HtmlEntry htmlEntry = sourceEntry;
     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("An HTML file became a non-HTML file: ${source.fullName}");
         }
@@ skipping 41 matching lines @@
     Source source = task.source;
     CaughtException thrownException = task.exception;
     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("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
     }
-    HtmlEntryImpl htmlEntry = sourceEntry;
+    HtmlEntry htmlEntry = sourceEntry;
     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("An HTML file became a non-HTML file: ${source.fullName}");
         }
@@ skipping 41 matching lines @@
     Source source = task.source;
     CaughtException thrownException = task.exception;
     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("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
     }
-    HtmlEntryImpl htmlEntry = sourceEntry;
+    HtmlEntry htmlEntry = sourceEntry;
     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("An HTML file became a non-HTML file: ${source.fullName}");
         }
@@ skipping 43 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;
     CaughtException thrownException = task.exception;
-    HtmlEntryImpl 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("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
     }
-    htmlEntry = sourceEntry as HtmlEntry;
+    HtmlEntry 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("An HTML file became a non-HTML file: ${source.fullName}");
         }
@@ skipping 46 matching lines @@
    * 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;
     CaughtException thrownException = task.exception;
-    DartEntryImpl 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("Internal error: attempting to resolve non-Dart file as a Dart file: ${unitSource.fullName}");
     }
-    dartEntry = sourceEntry as DartEntry;
+    DartEntry 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("A Dart file became a non-Dart file: ${unitSource.fullName}");
         }
@@ skipping 39 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;
     CaughtException thrownException = task.exception;
-    HtmlEntryImpl 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("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
     }
-    htmlEntry = sourceEntry as HtmlEntry;
+    HtmlEntry htmlEntry = sourceEntry;
     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("An HTML file became a non-HTML file: ${source.fullName}");
         }
@@ skipping 46 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;
     CaughtException thrownException = task.exception;
-    DartEntryImpl 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("Internal error: attempting to parse non-Dart file as a Dart file: ${source.fullName}");
     }
-    dartEntry = sourceEntry as DartEntry;
+    DartEntry dartEntry = sourceEntry;
     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("A Dart file became a non-Dart file: ${source.fullName}");
         }
@@ skipping 45 matching lines @@
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param librarySource the library to be removed
    * @param dartEntry the entry containing the list of included parts
    */
   void _removeFromParts(Source librarySource, DartEntry dartEntry) {
     List<Source> oldParts = dartEntry.getValue(DartEntry.INCLUDED_PARTS);
     for (int i = 0; i < oldParts.length; i++) {
       Source partSource = oldParts[i];
-      DartEntryImpl partEntry = _getReadableDartEntry(partSource);
+      DartEntry partEntry = _getReadableDartEntry(partSource);
       if (partEntry != null && !identical(partEntry, dartEntry)) {
         partEntry.removeContainingLibrary(librarySource);
         if (partEntry.containingLibraries.length == 0 && !exists(partSource)) {
           _cache.remove(partSource);
         }
       }
     }
   }
 
   /**
    * Remove the given libraries that are keys in the given map from the list of containing libraries
    * for each of the parts in the corresponding value.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param oldPartMap the table containing the parts associated with each library
    */
   void _removeFromPartsUsingMap(HashMap<Source, List<Source>> oldPartMap) {
     for (MapEntry<Source, List<Source>> entry in getMapEntrySet(oldPartMap)) {
       Source librarySource = entry.getKey();
       List<Source> oldParts = entry.getValue();
       for (int i = 0; i < oldParts.length; i++) {
         Source partSource = oldParts[i];
         if (partSource != librarySource) {
-          DartEntryImpl partEntry = _getReadableDartEntry(partSource);
+          DartEntry partEntry = _getReadableDartEntry(partSource);
           if (partEntry != null) {
             partEntry.removeContainingLibrary(librarySource);
             if (partEntry.containingLibraries.length == 0 && !exists(partSource)) {
               _cache.remove(partSource);
             }
           }
         }
       }
     }
   }
@@ skipping 47 matching lines @@
    * @param source the source that has been changed
    */
   void _sourceChanged(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null || sourceEntry.modificationTime == getModificationStamp(source)) {
       // Either we have removed this source, in which case we don't care that it is changed, or we
       // have already invalidated the cache and don't need to invalidate it again.
       return;
     }
     if (sourceEntry is HtmlEntry) {
-      HtmlEntryImpl htmlEntry = sourceEntry;
+      HtmlEntry htmlEntry = sourceEntry;
       htmlEntry.modificationTime = getModificationStamp(source);
       _invalidateAngularResolution(htmlEntry);
       htmlEntry.invalidateAllInformation();
       _cache.removedAst(source);
       _workManager.add(source, SourcePriority.HTML);
     } else if (sourceEntry is DartEntry) {
       List<Source> containingLibraries = getLibrariesContaining(source);
       HashSet<Source> librariesToInvalidate = new HashSet<Source>();
       for (Source containingLibrary in containingLibraries) {
         _computeAllLibrariesDependingOn(containingLibrary, librariesToInvalidate);
       }
       for (Source library in librariesToInvalidate) {
         _invalidateLibraryResolution(library);
       }
-      DartEntryImpl dartEntry = _cache.get(source);
+      DartEntry dartEntry = _cache.get(source);
       _removeFromParts(source, dartEntry);
       dartEntry.modificationTime = getModificationStamp(source);
       dartEntry.invalidateAllInformation();
       _cache.removedAst(source);
       _workManager.add(source, SourcePriority.UNKNOWN);
     }
   }
 
   /**
    * <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 htmlEntry = sourceEntry;
+      HtmlEntry htmlEntry = sourceEntry;
       _invalidateAngularResolution(htmlEntry);
       htmlEntry.recordContentError(new CaughtException(new AnalysisException("This source was marked as being deleted"), null));
     } else if (sourceEntry is DartEntry) {
-      DartEntryImpl dartEntry = sourceEntry;
+      DartEntry dartEntry = sourceEntry;
       HashSet<Source> libraries = new HashSet<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);
       }
@@ skipping 410 matching lines @@
    *          for all of the compilation units in the library
    */
   void _computePartsInLibrary(CycleBuilder_LibraryPair libraryPair) {
     ResolvableLibrary library = libraryPair.library;
     List<CycleBuilder_SourceEntryPair> entryPairs = libraryPair.entryPairs;
     int count = entryPairs.length;
     List<ResolvableCompilationUnit> units = new List<ResolvableCompilationUnit>(count);
     for (int i = 0; i < count; i++) {
       CycleBuilder_SourceEntryPair entryPair = entryPairs[i];
       Source source = entryPair.source;
-      DartEntryImpl dartEntry = entryPair.entry;
+      DartEntry dartEntry = entryPair.entry;
       units[i] = new ResolvableCompilationUnit.con2(dartEntry.modificationTime, dartEntry.resolvableCompilationUnit, source);
     }
     library.resolvableCompilationUnits = units;
   }
 
   /**
    * Create an object to represent the information about the library defined by the compilation
    * unit with the given source.
    *
    * @param librarySource the source of the library's defining compilation unit
@@ skipping 258 matching lines @@
  * The interface `AnalysisContextStatistics` defines access to statistics about a single
  * [AnalysisContext].
  */
 abstract class AnalysisContextStatistics {
   /**
    * Return the statistics for each kind of cached data.
    */
   List<AnalysisContextStatistics_CacheRow> get cacheRows;
 
   /**
-   * Return the exceptions that caused some entries to have a state of [CacheState#ERROR].
+   * Return the exceptions that caused some entries to have a state of [CacheState.ERROR].
    */
   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.
@@ skipping 125 matching lines @@
   final int totalCount;
 
   AnalysisContextStatisticsImpl_PartitionDataImpl(this.astCount, this.totalCount);
 }
 
 /**
  * Information about single piece of data in the cache.
  */
 abstract class AnalysisContextStatistics_CacheRow {
   /**
-   * Return the number of entries whose state is [CacheState#ERROR].
+   * Return the number of entries whose state is [CacheState.ERROR].
    */
   int get errorCount;
 
   /**
-   * Return the number of entries whose state is [CacheState#FLUSHED].
+   * Return the number of entries whose state is [CacheState.FLUSHED].
    */
   int get flushedCount;
 
   /**
-   * Return the number of entries whose state is [CacheState#IN_PROCESS].
+   * Return the number of entries whose state is [CacheState.IN_PROCESS].
    */
   int get inProcessCount;
 
   /**
-   * Return the number of entries whose state is [CacheState#INVALID].
+   * Return the number of entries whose state is [CacheState.INVALID].
    */
   int get invalidCount;
 
   /**
    * Return the name of the data represented by this object.
    */
   String get name;
 
   /**
-   * Return the number of entries whose state is [CacheState#VALID].
+   * Return the number of entries whose state is [CacheState.VALID].
    */
   int get validCount;
 }
 
 /**
  * Information about a single partition in the cache.
  */
 abstract class AnalysisContextStatistics_PartitionData {
   /**
    * Return the number of entries in the partition that have an AST structure in one state or
@@ skipping 13 matching lines @@
  */
 class AnalysisDelta {
   /**
    * A mapping from source to what type of analysis should be performed on that source.
    */
   HashMap<Source, AnalysisLevel> _analysisMap = new HashMap<Source, AnalysisLevel>();
 
   /**
    * Return a collection of the sources that have been added. This is equivalent to calling
    * [getAnalysisLevels] and collecting all sources that do not have an analysis level of
-   * [AnalysisLevel#NONE].
+   * [AnalysisLevel.NONE].
    *
    * @return a collection of the sources
    */
   Iterable<Source> get addedSources {
     List<Source> result = new List<Source>();
     for (MapEntry<Source, AnalysisLevel> entry in getMapEntrySet(_analysisMap)) {
       if (entry.getValue() != AnalysisLevel.NONE) {
         result.add(entry.getKey());
       }
     }
@@ skipping 894 matching lines @@
    * Return the offset of the first character in the expression's source range.
    */
   int get offset => expression.offset;
 }
 
 /**
  * Angular formatter argument.
  */
 class AngularFormatterArgument {
   /**
-   * The [TokenType#COLON] token.
+   * The [TokenType.COLON] token.
    */
   final Token token;
 
   /**
    * The argument expression.
    */
   final Expression expression;
 
   /**
    * The optional sub-[Expression]s.
    */
   List<Expression> subExpressions = Expression.EMPTY_ARRAY;
 
   AngularFormatterArgument(this.token, this.expression);
 }
 
 /**
  * Angular formatter node.
  */
 class AngularFormatterNode {
   /**
-   * The [TokenType#BAR] token.
+   * The [TokenType.BAR] token.
    */
   final Token token;
 
   /**
    * The name of the formatter.
    */
   final SimpleIdentifier name;
 
   /**
    * The arguments for this formatter.
@@ skipping 942 matching lines @@
    */
   MapIterator<Source, SourceEntry> iterator() => new SingleMapIterator<Source, SourceEntry>(_sourceMap);
 
   /**
    * Associate the given entry with the given source.
    *
    * @param source the source with which the entry is to be associated
    * @param entry the entry to be associated with the source
    */
   void put(Source source, SourceEntry entry) {
-    (entry as SourceEntryImpl).fixExceptionState();
+    entry.fixExceptionState();
     _sourceMap[source] = entry;
   }
 
   /**
    * Remove all information related to the given source from this cache.
    *
    * @param source the source to be removed
    */
   void remove(Source source) {
     _recentlyUsed.remove(source);
@@ skipping 52 matching lines @@
    *
    * @return `true` if a structure was flushed
    */
   bool _flushAstFromCache() {
     Source removedSource = _removeAstToFlush();
     if (removedSource == null) {
       return false;
     }
     SourceEntry sourceEntry = _sourceMap[removedSource];
     if (sourceEntry is HtmlEntry) {
-      HtmlEntryImpl htmlEntry = sourceEntry;
+      HtmlEntry htmlEntry = sourceEntry;
       htmlEntry.flushAstStructures();
     } else if (sourceEntry is DartEntry) {
-      DartEntryImpl dartEntry = sourceEntry;
+      DartEntry dartEntry = sourceEntry;
       dartEntry.flushAstStructures();
     }
     return true;
   }
 
   /**
    * Remove and return one source from the list of recently used sources whose AST structure can be
    * flushed from the cache. The source that will be returned will be the source that has been
    * unreferenced for the longest period of time but that is not a priority for analysis.
    *
@@ skipping 494 matching lines @@
    *
    * @param source the source associated with the entry
    * @param entry the entry associated with the source
    */
   CycleBuilder_SourceEntryPair(Source source, DartEntry entry) {
     this.source = source;
     this.entry = entry;
   }
 }
 
+
 /**
- * The interface `DartEntry` defines the behavior of objects that maintain the information
- * cached by an analysis context about an individual Dart file.
+ * A `DartEntry` maintains the information cached by an analysis context about
+ * an individual Dart file.
  */
-abstract class DartEntry implements SourceEntry {
-  /**
-   * The data descriptor representing the errors reported during Angular resolution.
-   */
-  static final DataDescriptor<List<AnalysisError>> ANGULAR_ERRORS = new DataDescriptor<List<AnalysisError>>("DartEntry.ANGULAR_ERRORS");
-
-  /**
-   * The data descriptor representing the list of libraries that contain this compilation unit.
-   */
-  static final DataDescriptor<List<Source>> CONTAINING_LIBRARIES = new DataDescriptor<List<Source>>("DartEntry.CONTAINING_LIBRARIES");
-
-  /**
-   * The data descriptor representing the library element for the library. This data is only
-   * available for Dart files that are the defining compilation unit of a library.
-   */
-  static final DataDescriptor<LibraryElement> ELEMENT = new DataDescriptor<LibraryElement>("DartEntry.ELEMENT");
-
-  /**
-   * The data descriptor representing the list of exported libraries. This data is only available
-   * for Dart files that are the defining compilation unit of a library.
-   */
-  static final DataDescriptor<List<Source>> EXPORTED_LIBRARIES = new DataDescriptor<List<Source>>("DartEntry.EXPORTED_LIBRARIES");
-
-  /**
-   * The data descriptor representing the hints resulting from auditing the source.
-   */
-  static final DataDescriptor<List<AnalysisError>> HINTS = new DataDescriptor<List<AnalysisError>>("DartEntry.HINTS");
-
-  /**
-   * The data descriptor representing the list of imported libraries. This data is only available
-   * for Dart files that are the defining compilation unit of a library.
-   */
-  static final DataDescriptor<List<Source>> IMPORTED_LIBRARIES = new DataDescriptor<List<Source>>("DartEntry.IMPORTED_LIBRARIES");
-
-  /**
-   * The data descriptor representing the list of included parts. This data is only available for
-   * Dart files that are the defining compilation unit of a library.
-   */
-  static final DataDescriptor<List<Source>> INCLUDED_PARTS = new DataDescriptor<List<Source>>("DartEntry.INCLUDED_PARTS");
-
-  /**
-   * The data descriptor representing the client flag. This data is only available for Dart files
-   * that are the defining compilation unit of a library.
-   */
-  static final DataDescriptor<bool> IS_CLIENT = new DataDescriptor<bool>("DartEntry.IS_CLIENT");
-
-  /**
-   * The data descriptor representing the launchable flag. This data is only available for Dart
-   * files that are the defining compilation unit of a library.
-   */
-  static final DataDescriptor<bool> IS_LAUNCHABLE = new DataDescriptor<bool>("DartEntry.IS_LAUNCHABLE");
-
-  /**
-   * The data descriptor representing the errors resulting from parsing the source.
-   */
-  static final DataDescriptor<List<AnalysisError>> PARSE_ERRORS = new DataDescriptor<List<AnalysisError>>("DartEntry.PARSE_ERRORS");
+class DartEntry extends SourceEntry {
+  /**
+   * The state of the cached token stream.
+   */
+  CacheState _tokenStreamState = CacheState.INVALID;
+
+  /**
+   * The head of the token stream, or `null` if the token stream is not
+   * currently cached.
+   */
+  Token _tokenStream;
+
+  /**
+   * The state of the cached scan errors.
+   */
+  CacheState _scanErrorsState = CacheState.INVALID;
+
+  /**
+   * The errors produced while scanning the compilation unit, or an empty array
+   * if the errors are not currently cached.
+   */
+  List<AnalysisError> _scanErrors = AnalysisError.NO_ERRORS;
+
+  /**
+   * The state of the cached source kind.
+   */
+  CacheState _sourceKindState = CacheState.INVALID;
+
+  /**
+   * The kind of this source.
+   */
+  SourceKind _sourceKind = SourceKind.UNKNOWN;
+
+  /**
+   * The state of the cached parsed compilation unit.
+   */
+  CacheState _parsedUnitState = CacheState.INVALID;
+
+  /**
+   * A flag indicating whether the parsed AST structure has been accessed since
+   * it was set. This is used to determine whether the structure needs to be
+   * copied before it is resolved.
+   */
+  bool _parsedUnitAccessed = false;
+
+  /**
+   * The parsed compilation unit, or `null` if the parsed compilation unit is
+   * not currently cached.
+   */
+  CompilationUnit _parsedUnit;
+
+  /**
+   * The state of the cached parse errors.
+   */
+  CacheState _parseErrorsState = CacheState.INVALID;
+
+  /**
+   * The errors produced while parsing the compilation unit, or an empty array
+   * if the errors are not currently cached.
+   */
+  List<AnalysisError> _parseErrors = AnalysisError.NO_ERRORS;
+
+  /**
+   * The state of the cached list of imported libraries.
+   */
+  CacheState _importedLibrariesState = CacheState.INVALID;
+
+  /**
+   * The list of libraries imported by the library, or an empty array if the
+   * list is not currently cached. The list will be empty if the Dart file is a
+   * part rather than a library.
+   */
+  List<Source> _importedLibraries = Source.EMPTY_ARRAY;
+
+  /**
+   * The state of the cached list of exported libraries.
+   */
+  CacheState _exportedLibrariesState = CacheState.INVALID;
+
+  /**
+   * The list of libraries exported by the library, or an empty array if the
+   * list is not currently cached. The list will be empty if the Dart file is a
+   * part rather than a library.
+   */
+  List<Source> _exportedLibraries = Source.EMPTY_ARRAY;
+
+  /**
+   * The state of the cached list of included parts.
+   */
+  CacheState _includedPartsState = CacheState.INVALID;
+
+  /**
+   * The list of parts included in the library, or an empty array if the list is
+   * not currently cached. The list will be empty if the Dart file is a part
+   * rather than a library.
+   */
+  List<Source> _includedParts = Source.EMPTY_ARRAY;
+
+  /**
+   * The list of libraries that contain this compilation unit. The list will be
+   * empty if there are no known libraries that contain this compilation unit.
+   */
+  List<Source> _containingLibraries = new List<Source>();
+
+  /**
+   * The information known as a result of resolving this compilation unit as
+   * part of the library that contains this unit. This field will never be
+   * `null`.
+   */
+  ResolutionState _resolutionState
+      = new ResolutionState();
+
+  /**
+   * The state of the cached library element.
+   */
+  CacheState _elementState = CacheState.INVALID;
+
+  /**
+   * The element representing the library, or `null` if the element is not
+   * currently cached.
+   */
+  LibraryElement _element;
+
+  /**
+   * The state of the cached public namespace.
+   */
+  CacheState _publicNamespaceState = CacheState.INVALID;
+
+  /**
+   * The public namespace of the library, or `null` if the namespace is not
+   * currently cached.
+   */
+  Namespace _publicNamespace;
+
+  /**
+   * The state of the cached client/ server flag.
+   */
+  CacheState _clientServerState = CacheState.INVALID;
+
+  /**
+   * The state of the cached launchable flag.
+   */
+  CacheState _launchableState = CacheState.INVALID;
+
+  /**
+   * The error produced while performing Angular resolution, or an empty array
+   * if there are no errors if the error are not currently cached.
+   */
+  List<AnalysisError> _angularErrors = AnalysisError.NO_ERRORS;
+
+  /**
+   * The data descriptor representing the errors reported during Angular
+   * resolution.
+   */
+  static final DataDescriptor<List<AnalysisError>> ANGULAR_ERRORS
+      = new DataDescriptor<List<AnalysisError>>("DartEntry.ANGULAR_ERRORS");
+
+  /**
+   * The data descriptor representing the list of libraries that contain this
+   * compilation unit.
+   */
+  static final DataDescriptor<List<Source>> CONTAINING_LIBRARIES
+      = new DataDescriptor<List<Source>>("DartEntry.CONTAINING_LIBRARIES");
+
+  /**
+   * The data descriptor representing the library element for the library. This
+   * data is only available for Dart files that are the defining compilation
+   * unit of a library.
+   */
+  static final DataDescriptor<LibraryElement> ELEMENT
+      = new DataDescriptor<LibraryElement>("DartEntry.ELEMENT");
+
+  /**
+   * The data descriptor representing the list of exported libraries. This data
+   * is only available for Dart files that are the defining compilation unit of
+   * a library.
+   */
+  static final DataDescriptor<List<Source>> EXPORTED_LIBRARIES
+      = new DataDescriptor<List<Source>>("DartEntry.EXPORTED_LIBRARIES");
+
+  /**
+   * The data descriptor representing the hints resulting from auditing the
+   * source.
+   */
+  static final DataDescriptor<List<AnalysisError>> HINTS
+      = new DataDescriptor<List<AnalysisError>>("DartEntry.HINTS");
+
+  /**
+   * The data descriptor representing the list of imported libraries. This data
+   * is only available for Dart files that are the defining compilation unit of
+   * a library.
+   */
+  static final DataDescriptor<List<Source>> IMPORTED_LIBRARIES
+      = new DataDescriptor<List<Source>>("DartEntry.IMPORTED_LIBRARIES");
+
+  /**
+   * The data descriptor representing the list of included parts. This data is
+   * only available for Dart files that are the defining compilation unit of a
+   * library.
+   */
+  static final DataDescriptor<List<Source>> INCLUDED_PARTS
+      = new DataDescriptor<List<Source>>("DartEntry.INCLUDED_PARTS");
+
+  /**
+   * The data descriptor representing the client flag. This data is only
+   * available for Dart files that are the defining compilation unit of a
+   * library.
+   */
+  static final DataDescriptor<bool> IS_CLIENT
+      = new DataDescriptor<bool>("DartEntry.IS_CLIENT");
+
+  /**
+   * The data descriptor representing the launchable flag. This data is only
+   * available for Dart files that are the defining compilation unit of a
+   * library.
+   */
+  static final DataDescriptor<bool> IS_LAUNCHABLE
+      = new DataDescriptor<bool>("DartEntry.IS_LAUNCHABLE");
+
+  /**
+   * The data descriptor representing the errors resulting from parsing the
+   * source.
+   */
+  static final DataDescriptor<List<AnalysisError>> PARSE_ERRORS
+      = new DataDescriptor<List<AnalysisError>>("DartEntry.PARSE_ERRORS");
 
   /**
    * The data descriptor representing the parsed AST structure.
    */
-  static final DataDescriptor<CompilationUnit> PARSED_UNIT = new DataDescriptor<CompilationUnit>("DartEntry.PARSED_UNIT");
-
-  /**
-   * The data descriptor representing the public namespace of the library. This data is only
-   * available for Dart files that are the defining compilation unit of a library.
-   */
-  static final DataDescriptor<Namespace> PUBLIC_NAMESPACE = new DataDescriptor<Namespace>("DartEntry.PUBLIC_NAMESPACE");
-
-  /**
-   * The data descriptor representing the errors resulting from resolving the source.
-   */
-  static final DataDescriptor<List<AnalysisError>> RESOLUTION_ERRORS = new DataDescriptor<List<AnalysisError>>("DartEntry.RESOLUTION_ERRORS");
+  static final DataDescriptor<CompilationUnit> PARSED_UNIT
+      = new DataDescriptor<CompilationUnit>("DartEntry.PARSED_UNIT");
+
+  /**
+   * The data descriptor representing the public namespace of the library. This
+   * data is only available for Dart files that are the defining compilation
+   * unit of a library.
+   */
+  static final DataDescriptor<Namespace> PUBLIC_NAMESPACE
+      = new DataDescriptor<Namespace>("DartEntry.PUBLIC_NAMESPACE");
+
+  /**
+   * The data descriptor representing the errors resulting from resolving the
+   * source.
+   */
+  static final DataDescriptor<List<AnalysisError>> RESOLUTION_ERRORS
+      = new DataDescriptor<List<AnalysisError>>("DartEntry.RESOLUTION_ERRORS");
 
   /**
    * The data descriptor representing the resolved AST structure.
    */
-  static final DataDescriptor<CompilationUnit> RESOLVED_UNIT = new DataDescriptor<CompilationUnit>("DartEntry.RESOLVED_UNIT");
+  static final DataDescriptor<CompilationUnit> RESOLVED_UNIT
+      = new DataDescriptor<CompilationUnit>("DartEntry.RESOLVED_UNIT");
 
   /**
    * The data descriptor representing the token stream.
    */
-  static final DataDescriptor<List<AnalysisError>> SCAN_ERRORS = new DataDescriptor<List<AnalysisError>>("DartEntry.SCAN_ERRORS");
+  static final DataDescriptor<List<AnalysisError>> SCAN_ERRORS
+      = new DataDescriptor<List<AnalysisError>>("DartEntry.SCAN_ERRORS");
 
   /**
    * The data descriptor representing the source kind.
    */
-  static final DataDescriptor<SourceKind> SOURCE_KIND = new DataDescriptor<SourceKind>("DartEntry.SOURCE_KIND");
+  static final DataDescriptor<SourceKind> SOURCE_KIND
+      = new DataDescriptor<SourceKind>("DartEntry.SOURCE_KIND");
 
   /**
    * The data descriptor representing the token stream.
    */
-  static final DataDescriptor<Token> TOKEN_STREAM = new DataDescriptor<Token>("DartEntry.TOKEN_STREAM");
-
-  /**
-   * The data descriptor representing the errors resulting from verifying the source.
-   */
-  static final DataDescriptor<List<AnalysisError>> VERIFICATION_ERRORS = new DataDescriptor<List<AnalysisError>>("DartEntry.VERIFICATION_ERRORS");
-
-  /**
-   * Return all of the errors associated with the compilation unit that are currently cached.
-   *
-   * @return all of the errors associated with the compilation unit
-   */
-  List<AnalysisError> get allErrors;
-
-  /**
-   * Return a valid parsed compilation unit, either an unresolved AST structure or the result of
-   * resolving the AST structure in the context of some library, or `null` if there is no
-   * parsed compilation unit available.
-   *
-   * @return a valid parsed compilation unit
-   */
-  CompilationUnit get anyParsedCompilationUnit;
-
-  /**
-   * Return the result of resolving the compilation unit as part of any library, or `null` if
-   * there is no cached resolved compilation unit.
-   *
-   * @return any resolved compilation unit
-   */
-  CompilationUnit get anyResolvedCompilationUnit;
-
-  /**
-   * Return the state of the data represented by the given descriptor in the context of the given
-   * library.
-   *
-   * @param descriptor the descriptor representing the data whose state is to be returned
-   * @param librarySource the source of the defining compilation unit of the library that is the
-   *          context for the data
-   * @return the value of the data represented by the given descriptor and library
-   */
-  CacheState getStateInLibrary(DataDescriptor descriptor, Source librarySource);
-
-  /**
-   * Return the value of the data represented by the given descriptor in the context of the given
-   * library, or `null` if the data represented by the descriptor is not in the cache.
-   *
-   * @param descriptor the descriptor representing which data is to be returned
-   * @param librarySource the source of the defining compilation unit of the library that is the
-   *          context for the data
-   * @return the value of the data represented by the given descriptor and library
-   */
-  Object getValueInLibrary(DataDescriptor descriptor, Source librarySource);
-
-  /**
-   * Return `true` if the data represented by the given descriptor is marked as being invalid.
-   * If the descriptor represents library-specific data then this method will return `true` if
-   * the data associated with any library it marked as invalid.
-   *
-   * @param descriptor the descriptor representing which data is being tested
-   * @return `true` if the data is marked as being invalid
-   */
-  bool hasInvalidData(DataDescriptor descriptor);
-
-  /**
-   * Return `true` if this entry has an AST structure that can be resolved (even if it needs
-   * to be copied).
-   *
-   * @return `true` if the method [DartEntryImpl#getResolvableCompilationUnit] will
-   *         return a non-`null` result
-   */
-  bool get hasResolvableCompilationUnit;
-
-  /**
-   * Return `true` if this data is safe to use in refactoring.
-   */
-  bool get isRefactoringSafe;
-}
-
-/**
- * Instances of the class `DartEntryImpl` implement a [DartEntry].
- */
-class DartEntryImpl extends SourceEntryImpl implements DartEntry {
-  /**
-   * The state of the cached token stream.
-   */
-  CacheState _tokenStreamState = CacheState.INVALID;
-
-  /**
-   * The head of the token stream, or `null` if the token stream is not currently cached.
-   */
-  Token _tokenStream;
-
-  /**
-   * The state of the cached scan errors.
-   */
-  CacheState _scanErrorsState = CacheState.INVALID;
-
-  /**
-   * The errors produced while scanning the compilation unit, or an empty array if the errors are
-   * not currently cached.
-   */
-  List<AnalysisError> _scanErrors = AnalysisError.NO_ERRORS;
-
-  /**
-   * The state of the cached source kind.
-   */
-  CacheState _sourceKindState = CacheState.INVALID;
-
-  /**
-   * The kind of this source.
-   */
-  SourceKind _sourceKind = SourceKind.UNKNOWN;
-
-  /**
-   * The state of the cached parsed compilation unit.
-   */
-  CacheState _parsedUnitState = CacheState.INVALID;
-
-  /**
-   * A flag indicating whether the parsed AST structure has been accessed since it was set. This is
-   * used to determine whether the structure needs to be copied before it is resolved.
-   */
-  bool _parsedUnitAccessed = false;
-
-  /**
-   * The parsed compilation unit, or `null` if the parsed compilation unit is not currently
-   * cached.
-   */
-  CompilationUnit _parsedUnit;
-
-  /**
-   * The state of the cached parse errors.
-   */
-  CacheState _parseErrorsState = CacheState.INVALID;
-
-  /**
-   * The errors produced while parsing the compilation unit, or an empty array if the errors are not
-   * currently cached.
-   */
-  List<AnalysisError> _parseErrors = AnalysisError.NO_ERRORS;
-
-  /**
-   * The state of the cached list of imported libraries.
-   */
-  CacheState _importedLibrariesState = CacheState.INVALID;
-
-  /**
-   * The list of libraries imported by the library, or an empty array if the list is not currently
-   * cached. The list will be empty if the Dart file is a part rather than a library.
-   */
-  List<Source> _importedLibraries = Source.EMPTY_ARRAY;
-
-  /**
-   * The state of the cached list of exported libraries.
-   */
-  CacheState _exportedLibrariesState = CacheState.INVALID;
-
-  /**
-   * The list of libraries exported by the library, or an empty array if the list is not currently
-   * cached. The list will be empty if the Dart file is a part rather than a library.
-   */
-  List<Source> _exportedLibraries = Source.EMPTY_ARRAY;
-
-  /**
-   * The state of the cached list of included parts.
-   */
-  CacheState _includedPartsState = CacheState.INVALID;
-
-  /**
-   * The list of parts included in the library, or an empty array if the list is not currently
-   * cached. The list will be empty if the Dart file is a part rather than a library.
-   */
-  List<Source> _includedParts = Source.EMPTY_ARRAY;
-
-  /**
-   * The list of libraries that contain this compilation unit. The list will be empty if there are
-   * no known libraries that contain this compilation unit.
-   */
-  List<Source> _containingLibraries = new List<Source>();
-
-  /**
-   * The information known as a result of resolving this compilation unit as part of the library
-   * that contains this unit. This field will never be `null`.
-   */
-  DartEntryImpl_ResolutionState _resolutionState = new DartEntryImpl_ResolutionState();
-
-  /**
-   * The state of the cached library element.
-   */
-  CacheState _elementState = CacheState.INVALID;
-
-  /**
-   * The element representing the library, or `null` if the element is not currently cached.
-   */
-  LibraryElement _element;
-
-  /**
-   * The state of the cached public namespace.
-   */
-  CacheState _publicNamespaceState = CacheState.INVALID;
-
-  /**
-   * The public namespace of the library, or `null` if the namespace is not currently cached.
-   */
-  Namespace _publicNamespace;
-
-  /**
-   * The state of the cached client/ server flag.
-   */
-  CacheState _clientServerState = CacheState.INVALID;
-
-  /**
-   * The state of the cached launchable flag.
-   */
-  CacheState _launchableState = CacheState.INVALID;
-
-  /**
-   * The error produced while performing Angular resolution, or an empty array if there are no
-   * errors if the error are not currently cached.
-   */
-  List<AnalysisError> _angularErrors = AnalysisError.NO_ERRORS;
-
-  /**
-   * The index of the flag indicating whether this library is launchable (whether the file has a
-   * main method).
+  static final DataDescriptor<Token> TOKEN_STREAM
+      = new DataDescriptor<Token>("DartEntry.TOKEN_STREAM");
+
+  /**
+   * The data descriptor representing the errors resulting from verifying the
+   * source.
+   */
+  static final DataDescriptor<List<AnalysisError>> VERIFICATION_ERRORS
+      = new DataDescriptor<List<AnalysisError>>("DartEntry.VERIFICATION_ERRORS");
+
+  /**
+   * The index of the flag indicating whether this library is launchable
+   * (whether the file has a main method).
    */
   static int _LAUNCHABLE_INDEX = 1;
 
   /**
-   * The index of the flag indicating whether the library is client code (whether the library
-   * depends on the html library). If the library is not "client code", then it is referred to as
-   * "server code".
+   * The index of the flag indicating whether the library is client code
+   * (whether the library depends on the html library). If the library is not
+   * "client code", then it is referred to as "server code".
    */
   static int _CLIENT_CODE_INDEX = 2;
 
   /**
-   * Add the given library to 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 added
+   * Add the given [librarySource] to the list of libraries that contain this
+   * part. This method should only be invoked on entries that represent a part.
    */
   void addContainingLibrary(Source librarySource) {
     _containingLibraries.add(librarySource);
   }
 
   /**
    * Flush any AST structures being maintained by this entry.
    */
   void flushAstStructures() {
     if (_tokenStreamState == CacheState.VALID) {
       _tokenStreamState = CacheState.FLUSHED;
       _tokenStream = null;
     }
     if (_parsedUnitState == CacheState.VALID) {
       _parsedUnitState = CacheState.FLUSHED;
       _parsedUnitAccessed = false;
       _parsedUnit = null;
     }
     _resolutionState.flushAstStructures();
   }
 
-  @override
+  /**
+   * Return all of the errors associated with the compilation unit that are
+   * currently cached.
+   */
   List<AnalysisError> get allErrors {
     List<AnalysisError> errors = new List<AnalysisError>();
     ListUtilities.addAll(errors, _scanErrors);
     ListUtilities.addAll(errors, _parseErrors);
-    DartEntryImpl_ResolutionState state = _resolutionState;
+    ResolutionState state = _resolutionState;
     while (state != null) {
       ListUtilities.addAll(errors, state._buildElementErrors);
       ListUtilities.addAll(errors, state._resolutionErrors);
       ListUtilities.addAll(errors, state._verificationErrors);
       ListUtilities.addAll(errors, state._hints);
       state = state._nextState;
     }
     ListUtilities.addAll(errors, _angularErrors);
     if (errors.length == 0) {
       return AnalysisError.NO_ERRORS;
     }
     return new List.from(errors);
   }
 
-  @override
+  /**
+   * Return a valid parsed compilation unit, either an unresolved AST structure
+   * or the result of resolving the AST structure in the context of some library,
+   * or `null` if there is no parsed compilation unit available.
+   */
   CompilationUnit get anyParsedCompilationUnit {
     if (_parsedUnitState == CacheState.VALID) {
       _parsedUnitAccessed = true;
       return _parsedUnit;
     }
-    DartEntryImpl_ResolutionState state = _resolutionState;
+    ResolutionState state = _resolutionState;
     while (state != null) {
       if (state._builtUnitState == CacheState.VALID) {
         return state._builtUnit;
       }
       state = state._nextState;
     }
     ;
     return anyResolvedCompilationUnit;
   }
 
-  @override
+  /**
+   * Return the result of resolving the compilation unit as part of any library,
+   * or `null` if there is no cached resolved compilation unit.
+   */
   CompilationUnit get anyResolvedCompilationUnit {
-    DartEntryImpl_ResolutionState state = _resolutionState;
+    ResolutionState state = _resolutionState;
     while (state != null) {
       if (state._resolvedUnitState == CacheState.VALID) {
         return state._resolvedUnit;
       }
       state = state._nextState;
     }
     ;
     return null;
   }
 
   /**
-   * Return a list containing the libraries that are known to contain this part.
-   *
-   * @return a list containing the libraries that are known to contain this part
+   * The libraries that are known to contain this part.
    */
   List<Source> get containingLibraries => _containingLibraries;
 
   @override
   SourceKind get kind => _sourceKind;
 
   /**
-   * Answer an array of library sources containing the receiver's source.
+   * The library sources containing the receiver's source.
    */
   List<Source> get librariesContaining {
-    DartEntryImpl_ResolutionState state = _resolutionState;
+    ResolutionState state = _resolutionState;
     List<Source> result = new List<Source>();
     while (state != null) {
       if (state._librarySource != null) {
         result.add(state._librarySource);
       }
       state = state._nextState;
     }
     return new List.from(result);
   }
 
   /**
-   * Return a compilation unit that has not been accessed by any other client and can therefore
-   * safely be modified by the reconciler, or `null` if the source has not been parsed.
-   *
-   * @return a compilation unit that can be modified by the reconciler
+   * A compilation unit that has not been accessed by any other client and can
+   * therefore safely be modified by the reconciler, or `null` if the source has
+   * not been parsed.
    */
   CompilationUnit get resolvableCompilationUnit {
     if (_parsedUnitState == CacheState.VALID) {
       if (_parsedUnitAccessed) {
         return _parsedUnit.accept(new AstCloner()) as CompilationUnit;
       }
       CompilationUnit unit = _parsedUnit;
       _parsedUnitState = CacheState.FLUSHED;
       _parsedUnitAccessed = false;
       _parsedUnit = null;
       return unit;
     }
-    DartEntryImpl_ResolutionState state = _resolutionState;
+    ResolutionState state = _resolutionState;
     while (state != null) {
       if (state._builtUnitState == CacheState.VALID) {
-        // TODO(brianwilkerson) We're cloning the structure to remove any previous resolution data,
-        // but I'm not sure that's necessary.
+        // TODO(brianwilkerson) We're cloning the structure to remove any
+        // previous resolution data, but I'm not sure that's necessary.
         return state._builtUnit.accept(new AstCloner()) as CompilationUnit;
       }
       if (state._resolvedUnitState == CacheState.VALID) {
         return state._resolvedUnit.accept(new AstCloner()) as CompilationUnit;
       }
       state = state._nextState;
     }
     ;
     return null;
   }
@@ skipping 22 matching lines @@
       return _scanErrorsState;
     } else if (identical(descriptor, DartEntry.SOURCE_KIND)) {
       return _sourceKindState;
     } else if (identical(descriptor, DartEntry.TOKEN_STREAM)) {
       return _tokenStreamState;
     } else {
       return super.getState(descriptor);
     }
   }
 
-  @override
+  /**
+   * Return the state of the data represented by the given [descriptor] in the
+   * context of the given [librarySource].
+   */
   CacheState getStateInLibrary(DataDescriptor descriptor, Source librarySource) {
-    DartEntryImpl_ResolutionState state = _resolutionState;
+    ResolutionState state = _resolutionState;
     while (state != null) {
       if (librarySource == state._librarySource) {
         if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
           return state._resolutionErrorsState;
         } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
           return state._resolvedUnitState;
         } else if (identical(descriptor, DartEntry.VERIFICATION_ERRORS)) {
           return state._verificationErrorsState;
         } else if (identical(descriptor, DartEntry.HINTS)) {
           return state._hintsState;
         } else {
           throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
         }
       }
       state = state._nextState;
     }
     ;
-    if (identical(descriptor, DartEntry.RESOLUTION_ERRORS) || identical(descriptor, DartEntry.RESOLVED_UNIT) || identical(descriptor, DartEntry.VERIFICATION_ERRORS) || identical(descriptor, DartEntry.HINTS)) {
+    if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)
+        || identical(descriptor, DartEntry.RESOLVED_UNIT)
+        || identical(descriptor, DartEntry.VERIFICATION_ERRORS)
+        || identical(descriptor, DartEntry.HINTS)) {
       return CacheState.INVALID;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
 
   @override
   Object getValue(DataDescriptor descriptor) {
     if (identical(descriptor, DartEntry.ANGULAR_ERRORS)) {
       return _angularErrors;
@@ skipping 21 matching lines @@
     } else if (identical(descriptor, DartEntry.SCAN_ERRORS)) {
       return _scanErrors;
     } else if (identical(descriptor, DartEntry.SOURCE_KIND)) {
       return _sourceKind;
     } else if (identical(descriptor, DartEntry.TOKEN_STREAM)) {
       return _tokenStream;
     }
     return super.getValue(descriptor);
   }
 
-  @override
+  /**
+   * Return the value of the data represented by the given [descriptor] in the
+   * context of the given [librarySource], or `null` if the data represented by
+   * the descriptor is not in the cache.
+   */
   Object getValueInLibrary(DataDescriptor descriptor, Source librarySource) {
-    DartEntryImpl_ResolutionState state = _resolutionState;
+    ResolutionState state = _resolutionState;
     while (state != null) {
       if (librarySource == state._librarySource) {
         if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
           return state._resolutionErrors;
         } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
           return state._resolvedUnit;
         } else if (identical(descriptor, DartEntry.VERIFICATION_ERRORS)) {
           return state._verificationErrors;
         } else if (identical(descriptor, DartEntry.HINTS)) {
           return state._hints;
         } else {
           throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
         }
       }
       state = state._nextState;
     }
     ;
-    if (identical(descriptor, DartEntry.RESOLUTION_ERRORS) || identical(descriptor, DartEntry.VERIFICATION_ERRORS) || identical(descriptor, DartEntry.HINTS)) {
+    if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)
+        || identical(descriptor, DartEntry.VERIFICATION_ERRORS)
+        || identical(descriptor, DartEntry.HINTS)) {
       return AnalysisError.NO_ERRORS;
     } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
       return null;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
 
-  @override
+  /**
+   * Return `true` if the data represented by the given [descriptor] is marked
+   * as being invalid. If the descriptor represents library-specific data then
+   * this method will return `true` if the data associated with any library it
+   * marked as invalid.
+   */
   bool hasInvalidData(DataDescriptor descriptor) {
     if (identical(descriptor, DartEntry.ELEMENT)) {
       return _elementState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.EXPORTED_LIBRARIES)) {
       return _exportedLibrariesState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.IMPORTED_LIBRARIES)) {
       return _importedLibrariesState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.INCLUDED_PARTS)) {
       return _includedPartsState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.IS_CLIENT)) {
       return _clientServerState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.IS_LAUNCHABLE)) {
       return _launchableState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.PARSE_ERRORS)) {
       return _parseErrorsState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.PARSED_UNIT)) {
       return _parsedUnitState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.PUBLIC_NAMESPACE)) {
       return _publicNamespaceState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.SCAN_ERRORS)) {
       return _scanErrorsState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.SOURCE_KIND)) {
       return _sourceKindState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.TOKEN_STREAM)) {
       return _tokenStreamState == CacheState.INVALID;
-    } else if (identical(descriptor, DartEntry.RESOLUTION_ERRORS) || identical(descriptor, DartEntry.RESOLVED_UNIT) || identical(descriptor, DartEntry.VERIFICATION_ERRORS) || identical(descriptor, DartEntry.HINTS)) {
-      DartEntryImpl_ResolutionState state = _resolutionState;
+    } else if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)
+        || identical(descriptor, DartEntry.RESOLVED_UNIT)
+        || identical(descriptor, DartEntry.VERIFICATION_ERRORS)
+        || identical(descriptor, DartEntry.HINTS)) {
+      ResolutionState state = _resolutionState;
       while (state != null) {
         if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
           return state._resolutionErrorsState == CacheState.INVALID;
         } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
           return state._resolvedUnitState == CacheState.INVALID;
         } else if (identical(descriptor, DartEntry.VERIFICATION_ERRORS)) {
           return state._verificationErrorsState == CacheState.INVALID;
         } else if (identical(descriptor, DartEntry.HINTS)) {
           return state._hintsState == CacheState.INVALID;
         }
       }
       return false;
     } else {
       return super.getState(descriptor) == CacheState.INVALID;
     }
   }
 
-  @override
+  /**
+   * Return `true` if this entry has an AST structure that can be resolved, even
+   * if it needs to be copied. Returning `true` implies that the method
+   * [resolvableCompilationUnit] will return a non-`null` result.
+   */
   bool get hasResolvableCompilationUnit {
     if (_parsedUnitState == CacheState.VALID) {
       return true;
     }
-    DartEntryImpl_ResolutionState state = _resolutionState;
+    ResolutionState state = _resolutionState;
     while (state != null) {
-      if (state._builtUnitState == CacheState.VALID || state._resolvedUnitState == CacheState.VALID) {
+      if (state._builtUnitState == CacheState.VALID
+          || state._resolvedUnitState == CacheState.VALID) {
         return true;
       }
       state = state._nextState;
     }
     ;
     return false;
   }
 
   @override
   void invalidateAllInformation() {
     super.invalidateAllInformation();
     _scanErrors = AnalysisError.NO_ERRORS;
     _scanErrorsState = CacheState.INVALID;
     _tokenStream = null;
     _tokenStreamState = CacheState.INVALID;
     _sourceKind = SourceKind.UNKNOWN;
     _sourceKindState = CacheState.INVALID;
     _parseErrors = AnalysisError.NO_ERRORS;
     _parseErrorsState = CacheState.INVALID;
     _parsedUnit = null;
     _parsedUnitAccessed = false;
     _parsedUnitState = CacheState.INVALID;
     _discardCachedResolutionInformation(true);
   }
 
   /**
-   * Invalidate all of the resolution information associated with the compilation unit.
-   *
-   * @param invalidateUris true if the cached results of converting URIs to source files should also
-   *          be invalidated.
+   * Invalidate all of the resolution information associated with the
+   * compilation unit. The flag [invalidateUris] should be `true` if the cached
+   * results of converting URIs to source files should also be invalidated.
    */
   void invalidateAllResolutionInformation(bool invalidateUris) {
     if (_parsedUnitState == CacheState.FLUSHED) {
-      DartEntryImpl_ResolutionState state = _resolutionState;
+      ResolutionState state = _resolutionState;
       while (state != null) {
         if (state._builtUnitState == CacheState.VALID) {
           _parsedUnit = state._builtUnit;
           _parsedUnitAccessed = true;
           _parsedUnitState = CacheState.VALID;
           break;
         } else if (state._resolvedUnitState == CacheState.VALID) {
           _parsedUnit = state._resolvedUnit;
           _parsedUnitAccessed = true;
           _parsedUnitState = CacheState.VALID;
           break;
         }
         state = state._nextState;
       }
     }
     _discardCachedResolutionInformation(invalidateUris);
   }
 
-  @override
+  /**
+   * Return `true` if this data is safe to use in refactoring.
+   */
   bool get isRefactoringSafe {
-    DartEntryImpl_ResolutionState state = _resolutionState;
+    ResolutionState state = _resolutionState;
     while (state != null) {
       CacheState resolvedState = state._resolvedUnitState;
-      if (resolvedState != CacheState.VALID && resolvedState != CacheState.FLUSHED) {
+      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.
+   * 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, 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);
+    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.
+   * 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(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.
+   * 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, CaughtException exception) {
     this.exception = exception;
-    DartEntryImpl_ResolutionState state = _getOrCreateResolutionState(librarySource);
+    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
+   * Record that an [exception] 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.
    */
   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;
     _importedLibrariesState = CacheState.ERROR;
     _includedParts = Source.EMPTY_ARRAY;
     _includedPartsState = CacheState.ERROR;
     recordResolutionError(exception);
   }
 
   /**
-   * Record that the parse-related information for the associated source is about to be computed by
-   * the current thread.
+   * Record that the parse-related information for the associated source is
+   * about to be computed by the current thread.
    */
   void recordParseInProcess() {
     if (_sourceKindState != CacheState.VALID) {
       _sourceKindState = CacheState.IN_PROCESS;
     }
     if (_parseErrorsState != CacheState.VALID) {
       _parseErrorsState = CacheState.IN_PROCESS;
     }
     if (_parsedUnitState != CacheState.VALID) {
       _parsedUnitState = CacheState.IN_PROCESS;
     }
     if (_exportedLibrariesState != CacheState.VALID) {
       _exportedLibrariesState = CacheState.IN_PROCESS;
     }
     if (_importedLibrariesState != CacheState.VALID) {
       _importedLibrariesState = CacheState.IN_PROCESS;
     }
     if (_includedPartsState != CacheState.VALID) {
       _includedPartsState = CacheState.IN_PROCESS;
     }
   }
 
   /**
-   * Record that an in-process parse has stopped without recording results because the results were
-   * invalidated before they could be recorded.
+   * Record that an in-process parse has stopped without recording results
+   * because the results were invalidated before they could be recorded.
    */
   void recordParseNotInProcess() {
     if (getState(SourceEntry.LINE_INFO) == CacheState.IN_PROCESS) {
       setState(SourceEntry.LINE_INFO, CacheState.INVALID);
     }
     if (_sourceKindState == CacheState.IN_PROCESS) {
       _sourceKindState = CacheState.INVALID;
     }
     if (_parseErrorsState == CacheState.IN_PROCESS) {
       _parseErrorsState = CacheState.INVALID;
     }
     if (_parsedUnitState == CacheState.IN_PROCESS) {
       _parsedUnitState = CacheState.INVALID;
     }
     if (_exportedLibrariesState == CacheState.IN_PROCESS) {
       _exportedLibrariesState = CacheState.INVALID;
     }
     if (_importedLibrariesState == CacheState.IN_PROCESS) {
       _importedLibrariesState = CacheState.INVALID;
     }
     if (_includedPartsState == CacheState.IN_PROCESS) {
       _includedPartsState = CacheState.INVALID;
     }
   }
 
   /**
-   * Record that an error occurred while attempting to resolve the source represented by this entry.
-   * This will set the state of all resolution-based information as being in error, but will not
-   * change the state of any parse results.
+   * Record that an [exception] 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(CaughtException exception) {
     this.exception = exception;
     _element = null;
     _elementState = CacheState.ERROR;
     clearFlags([_LAUNCHABLE_INDEX, _CLIENT_CODE_INDEX]);
     _clientServerState = CacheState.ERROR;
     _launchableState = CacheState.ERROR;
@@ skipping 12 matching lines @@
    */
   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);
+    ResolutionState state = _getOrCreateResolutionState(librarySource);
     state.recordResolutionError();
   }
 
   /**
    * Record that an in-process resolution has stopped without recording results because the results
    * were invalidated before they could be recorded.
    */
   void recordResolutionNotInProcess() {
     if (_elementState == CacheState.IN_PROCESS) {
       _elementState = CacheState.INVALID;
     }
     if (_clientServerState == CacheState.IN_PROCESS) {
       _clientServerState = CacheState.INVALID;
     }
     if (_launchableState == CacheState.IN_PROCESS) {
       _launchableState = CacheState.INVALID;
     }
     // TODO(brianwilkerson) Remove the code above this line after resolution and element building
     // are separated.
     if (_publicNamespaceState == CacheState.IN_PROCESS) {
       _publicNamespaceState = CacheState.INVALID;
     }
     _resolutionState.recordResolutionNotInProcess();
   }
 
   /**
-   * Record that an error occurred while attempting to scan or parse the entry represented by this
-   * entry. This will set the state of all information, including any resolution-based information,
-   * as being in error.
-   *
-   * @param exception the exception that shows where the error occurred
+   * Record that an [exception] 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.
    */
   @override
   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
-   * the current thread.
+   * Record that the scan-related information for the associated source is about
+   * to be computed by the current thread.
    */
   void recordScanInProcess() {
     if (getState(SourceEntry.LINE_INFO) != CacheState.VALID) {
       setState(SourceEntry.LINE_INFO, CacheState.IN_PROCESS);
     }
     if (_scanErrorsState != CacheState.VALID) {
       _scanErrorsState = CacheState.IN_PROCESS;
     }
     if (_tokenStreamState != CacheState.VALID) {
       _tokenStreamState = CacheState.IN_PROCESS;
     }
   }
 
   /**
-   * Record that an in-process scan has stopped without recording results because the results were
-   * invalidated before they could be recorded.
+   * Record that an in-process scan has stopped without recording results
+   * because the results were invalidated before they could be recorded.
    */
   void recordScanNotInProcess() {
     if (getState(SourceEntry.LINE_INFO) == CacheState.IN_PROCESS) {
       setState(SourceEntry.LINE_INFO, CacheState.INVALID);
     }
     if (_scanErrorsState == CacheState.IN_PROCESS) {
       _scanErrorsState = CacheState.INVALID;
     }
     if (_tokenStreamState == CacheState.IN_PROCESS) {
       _tokenStreamState = CacheState.INVALID;
     }
   }
 
   /**
-   * Record that an error occurred while attempting to generate errors and warnings for the source
-   * represented by this entry. This will set the state of all verification information as being in
-   * error.
+   * Record that an [exception] 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, CaughtException exception) {
     this.exception = exception;
-    DartEntryImpl_ResolutionState state = _getOrCreateResolutionState(librarySource);
+    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.
+   * Remove the given [library] from the list of libraries that contain this
+   * part. This method should only be invoked on entries that represent a part.
    *
    * @param librarySource the source of the library to be removed
    */
-  void removeContainingLibrary(Source librarySource) {
-    _containingLibraries.remove(librarySource);
+  void removeContainingLibrary(Source library) {
+    _containingLibraries.remove(library);
   }
 
   /**
-   * Remove any resolution information associated with this compilation unit being part of the given
-   * library, presumably because it is no longer part of the library.
-   *
-   * @param librarySource the source of the defining compilation unit of the library that used to
-   *          contain this part but no longer does
+   * Remove any resolution information associated with this compilation unit
+   * being part of the given [library], presumably because it is no longer part
+   * of the library.
    */
-  void removeResolution(Source librarySource) {
-    if (librarySource != null) {
-      if (librarySource == _resolutionState._librarySource) {
+  void removeResolution(Source library) {
+    if (library != null) {
+      if (library == _resolutionState._librarySource) {
         if (_resolutionState._nextState == null) {
           _resolutionState.invalidateAllResolutionInformation();
         } else {
           _resolutionState = _resolutionState._nextState;
         }
       } else {
-        DartEntryImpl_ResolutionState priorState = _resolutionState;
-        DartEntryImpl_ResolutionState state = _resolutionState._nextState;
+        ResolutionState priorState = _resolutionState;
+        ResolutionState state = _resolutionState._nextState;
         while (state != null) {
-          if (librarySource == state._librarySource) {
+          if (library == state._librarySource) {
             priorState._nextState = state._nextState;
             break;
           }
           priorState = state;
           state = state._nextState;
         }
       }
     }
   }
 
   /**
-   * Set the list of libraries that contain this compilation unit to contain only the given source.
-   * This method should only be invoked on entries that represent a library.
+   * Set the list of libraries that contain this compilation unit to contain
+   * only the given source. This method should only be invoked on entries that
+   * represent a library.
    *
    * @param librarySource the source of the single library that the list should contain
    */
   void set containingLibrary(Source librarySource) {
     _containingLibraries.clear();
     _containingLibraries.add(librarySource);
   }
 
   @override
   void setState(DataDescriptor descriptor, CacheState state) {
@@ skipping 45 matching lines @@
   /**
    * Set the state of the data represented by the given descriptor in the context of the given
    * library to the given state.
    *
    * @param descriptor the descriptor representing the data whose state is to be set
    * @param librarySource the source of the defining compilation unit of the library that is the
    *          context for the data
    * @param cacheState the new state of the data represented by the given descriptor
    */
   void setStateInLibrary(DataDescriptor descriptor, Source librarySource, CacheState cacheState) {
-    DartEntryImpl_ResolutionState state = _getOrCreateResolutionState(librarySource);
+    ResolutionState state = _getOrCreateResolutionState(librarySource);
     if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
       state._resolutionErrors = updatedValue(cacheState, state._resolutionErrors, AnalysisError.NO_ERRORS);
       state._resolutionErrorsState = cacheState;
     } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
       state._resolvedUnit = updatedValue(cacheState, state._resolvedUnit, null);
       state._resolvedUnitState = cacheState;
     } else if (identical(descriptor, DartEntry.VERIFICATION_ERRORS)) {
       state._verificationErrors = updatedValue(cacheState, state._verificationErrors, AnalysisError.NO_ERRORS);
       state._verificationErrorsState = cacheState;
     } else if (identical(descriptor, DartEntry.HINTS)) {
@@ skipping 45 matching lines @@
     } else if (identical(descriptor, DartEntry.TOKEN_STREAM)) {
       _tokenStream = value as Token;
       _tokenStreamState = CacheState.VALID;
     } else {
       super.setValue(descriptor, value);
     }
   }
 
   /**
    * Set the value of the data represented by the given descriptor in the context of the given
-   * library to the given value, and set the state of that data to [CacheState#VALID].
+   * library to the given value, and set the state of that data to [CacheState.VALID].
    *
    * @param descriptor the descriptor representing which data is to have its value set
    * @param librarySource the source of the defining compilation unit of the library that is the
    *          context for the data
    * @param value the new value of the data represented by the given descriptor and library
    */
   void setValueInLibrary(DataDescriptor descriptor, Source librarySource, Object value) {
-    DartEntryImpl_ResolutionState state = _getOrCreateResolutionState(librarySource);
+    ResolutionState state = _getOrCreateResolutionState(librarySource);
     if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
       state._resolutionErrors = value == null ? AnalysisError.NO_ERRORS : (value as List<AnalysisError>);
       state._resolutionErrorsState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
       state._resolvedUnit = value as CompilationUnit;
       state._resolvedUnitState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.VERIFICATION_ERRORS)) {
       state._verificationErrors = value == null ? AnalysisError.NO_ERRORS : (value as List<AnalysisError>);
       state._verificationErrorsState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.HINTS)) {
       state._hints = value == null ? AnalysisError.NO_ERRORS : (value as List<AnalysisError>);
       state._hintsState = CacheState.VALID;
     }
   }
 
   @override
   bool get hasErrorState => super.hasErrorState || _scanErrorsState == CacheState.ERROR || _tokenStreamState == CacheState.ERROR || _sourceKindState == CacheState.ERROR || _parsedUnitState == CacheState.ERROR || _parseErrorsState == CacheState.ERROR || _importedLibrariesState == CacheState.ERROR || _exportedLibrariesState == CacheState.ERROR || _includedPartsState == CacheState.ERROR || _elementState == CacheState.ERROR || _publicNamespaceState == CacheState.ERROR || _clientServerState == CacheState.ERROR || _launchableState == CacheState.ERROR || _resolutionState.hasErrorState;
 
   @override
   bool writeDiffOn(JavaStringBuilder builder, SourceEntry oldEntry) {
     bool needsSeparator = super.writeDiffOn(builder, oldEntry);
-    if (oldEntry is! DartEntryImpl) {
+    if (oldEntry is! DartEntry) {
       if (needsSeparator) {
         builder.append("; ");
       }
       builder.append("entry type changed; was ${oldEntry.runtimeType.toString()}");
       return true;
     }
     needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.TOKEN_STREAM, "tokenStream");
     needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.SCAN_ERRORS, "scanErrors");
     needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.SOURCE_KIND, "sourceKind");
     needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.PARSED_UNIT, "parsedUnit");
     needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.PARSE_ERRORS, "parseErrors");
     needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.IMPORTED_LIBRARIES, "importedLibraries");
     needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.EXPORTED_LIBRARIES, "exportedLibraries");
     needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.INCLUDED_PARTS, "includedParts");
     needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.ELEMENT, "element");
     needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.PUBLIC_NAMESPACE, "publicNamespace");
     needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.IS_CLIENT, "clientServer");
     needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.IS_LAUNCHABLE, "launchable");
     // TODO(brianwilkerson) Add better support for containingLibraries. It would be nice to be able
     // to report on size-preserving changes.
-    int oldLibraryCount = (oldEntry as DartEntryImpl)._containingLibraries.length;
+    int oldLibraryCount = (oldEntry as DartEntry)._containingLibraries.length;
     int libraryCount = _containingLibraries.length;
     if (oldLibraryCount != libraryCount) {
       if (needsSeparator) {
         builder.append("; ");
       }
       builder.append("containingLibraryCount = ");
       builder.append(oldLibraryCount);
       builder.append(" -> ");
       builder.append(libraryCount);
       needsSeparator = true;
     }
     //
     // Report change to the per-library state.
     //
-    HashMap<Source, DartEntryImpl_ResolutionState> oldStateMap = new HashMap<Source, DartEntryImpl_ResolutionState>();
-    DartEntryImpl_ResolutionState state = (oldEntry as DartEntryImpl)._resolutionState;
+    HashMap<Source, ResolutionState> oldStateMap = new HashMap<Source, ResolutionState>();
+    ResolutionState state = (oldEntry as DartEntry)._resolutionState;
     while (state != null) {
       Source librarySource = state._librarySource;
       if (librarySource != null) {
         oldStateMap[librarySource] = state;
       }
       state = state._nextState;
     }
     state = _resolutionState;
     while (state != null) {
       Source librarySource = state._librarySource;
       if (librarySource != null) {
-        DartEntryImpl_ResolutionState oldState = oldStateMap.remove(librarySource);
+        ResolutionState oldState = oldStateMap.remove(librarySource);
         if (oldState == null) {
           if (needsSeparator) {
             builder.append("; ");
           }
           builder.append("added resolution for ");
           builder.append(librarySource.fullName);
           needsSeparator = true;
         } else {
           needsSeparator = oldState.writeDiffOn(builder, needsSeparator, oldEntry as DartEntry);
         }
@@ skipping 69 matching lines @@
       _includedPartsState = CacheState.INVALID;
     }
   }
 
   /**
    * Return a resolution state for the specified library, creating one as necessary.
    *
    * @param librarySource the library source (not `null`)
    * @return the resolution state (not `null`)
    */
-  DartEntryImpl_ResolutionState _getOrCreateResolutionState(Source librarySource) {
-    DartEntryImpl_ResolutionState state = _resolutionState;
+  ResolutionState _getOrCreateResolutionState(Source librarySource) {
+    ResolutionState state = _resolutionState;
     if (state._librarySource == null) {
       state._librarySource = librarySource;
       return state;
     }
     while (state._librarySource != librarySource) {
       if (state._nextState == null) {
-        DartEntryImpl_ResolutionState newState = new DartEntryImpl_ResolutionState();
+        ResolutionState newState = new ResolutionState();
         newState._librarySource = librarySource;
         state._nextState = newState;
         return newState;
       }
       state = state._nextState;
     }
     return state;
   }
 
   /**
@@ skipping 10 matching lines @@
       //
       // If the value is in process, we can leave the current value in the cache for any 'get'
       // methods to access.
       //
       setFlag(index, false);
     }
   }
 }
 
 /**
- * Instances of the class `ResolutionState` represent the information produced by resolving
- * a compilation unit as part of a specific library.
- */
-class DartEntryImpl_ResolutionState {
-  /**
-   * The next resolution state or `null` if none.
-   */
-  DartEntryImpl_ResolutionState _nextState;
-
-  /**
-   * The source for the defining compilation unit of the library that contains this unit. If this
-   * unit is the defining compilation unit for it's library, then this will be the source for this
-   * unit.
-   */
-  Source _librarySource;
-
-  /**
-   * The state of the cached compilation unit that contains references to the built element model.
-   */
-  CacheState _builtUnitState = CacheState.INVALID;
-
-  /**
-   * The compilation unit that contains references to the built element model, or `null` if
-   * that compilation unit is not currently cached.
-   */
-  CompilationUnit _builtUnit;
-
-  /**
-   * The state of the cached errors reported while building an element model.
-   */
-  CacheState _buildElementErrorsState = CacheState.INVALID;
-
-  /**
-   * The errors produced while building an element model, or an empty array if the errors are not
-   * currently cached.
-   */
-  List<AnalysisError> _buildElementErrors = AnalysisError.NO_ERRORS;
-
-  /**
-   * The state of the cached resolved compilation unit.
-   */
-  CacheState _resolvedUnitState = CacheState.INVALID;
-
-  /**
-   * The resolved compilation unit, or `null` if the resolved compilation unit is not
-   * currently cached.
-   */
-  CompilationUnit _resolvedUnit;
-
-  /**
-   * The state of the cached resolution errors.
-   */
-  CacheState _resolutionErrorsState = CacheState.INVALID;
-
-  /**
-   * The errors produced while resolving the compilation unit, or an empty array if the errors are
-   * not currently cached.
-   */
-  List<AnalysisError> _resolutionErrors = AnalysisError.NO_ERRORS;
-
-  /**
-   * The state of the cached verification errors.
-   */
-  CacheState _verificationErrorsState = CacheState.INVALID;
-
-  /**
-   * The errors produced while verifying the compilation unit, or an empty array if the errors are
-   * not currently cached.
-   */
-  List<AnalysisError> _verificationErrors = AnalysisError.NO_ERRORS;
-
-  /**
-   * The state of the cached hints.
-   */
-  CacheState _hintsState = CacheState.INVALID;
-
-  /**
-   * The hints produced while auditing the compilation unit, or an empty array if the hints are
-   * not currently cached.
-   */
-  List<AnalysisError> _hints = AnalysisError.NO_ERRORS;
-
-  /**
-   * Flush any AST structures being maintained by this state.
-   */
-  void flushAstStructures() {
-    if (_builtUnitState == CacheState.VALID) {
-      _builtUnitState = CacheState.FLUSHED;
-      _builtUnit = null;
-    }
-    if (_resolvedUnitState == CacheState.VALID) {
-      _resolvedUnitState = CacheState.FLUSHED;
-      _resolvedUnit = null;
-    }
-    if (_nextState != null) {
-      _nextState.flushAstStructures();
-    }
-  }
-
-  bool get hasErrorState => _builtUnitState == CacheState.ERROR || _buildElementErrorsState == CacheState.ERROR || _resolvedUnitState == CacheState.ERROR || _resolutionErrorsState == CacheState.ERROR || _verificationErrorsState == CacheState.ERROR || _hintsState == CacheState.ERROR || (_nextState != null && _nextState.hasErrorState);
-
-  /**
-   * Invalidate all of the resolution information associated with the compilation unit.
-   */
-  void invalidateAllResolutionInformation() {
-    _nextState = null;
-    _librarySource = null;
-    _builtUnitState = CacheState.INVALID;
-    _builtUnit = null;
-    _buildElementErrorsState = CacheState.INVALID;
-    _buildElementErrors = AnalysisError.NO_ERRORS;
-    _resolvedUnitState = CacheState.INVALID;
-    _resolvedUnit = null;
-    _resolutionErrorsState = CacheState.INVALID;
-    _resolutionErrors = AnalysisError.NO_ERRORS;
-    _verificationErrorsState = CacheState.INVALID;
-    _verificationErrors = AnalysisError.NO_ERRORS;
-    _hintsState = CacheState.INVALID;
-    _hints = AnalysisError.NO_ERRORS;
-  }
-
-  /**
-   * Record that an error occurred while attempting to build the element model for the source
-   * represented by this state.
-   */
-  void recordBuildElementError() {
-    _builtUnitState = CacheState.ERROR;
-    _builtUnit = null;
-    _buildElementErrorsState = CacheState.ERROR;
-    _buildElementErrors = AnalysisError.NO_ERRORS;
-    recordResolutionError();
-  }
-
-  /**
-   * Record that an error occurred while attempting to generate hints for the source represented
-   * by this entry. This will set the state of all verification information as being in error.
-   */
-  void recordHintError() {
-    _hints = AnalysisError.NO_ERRORS;
-    _hintsState = CacheState.ERROR;
-  }
-
-  /**
-   * Record that an error occurred while attempting to resolve the source represented by this
-   * state.
-   */
-  void recordResolutionError() {
-    _resolvedUnitState = CacheState.ERROR;
-    _resolvedUnit = null;
-    _resolutionErrorsState = CacheState.ERROR;
-    _resolutionErrors = AnalysisError.NO_ERRORS;
-    recordVerificationError();
-  }
-
-  /**
-   * Record that an error occurred while attempting to scan or parse the entry represented by this
-   * entry. This will set the state of all resolution-based information as being in error, but
-   * will not change the state of any parse results.
-   */
-  void recordResolutionErrorsInAllLibraries() {
-    _builtUnitState = CacheState.ERROR;
-    _builtUnit = null;
-    _buildElementErrorsState = CacheState.ERROR;
-    _buildElementErrors = AnalysisError.NO_ERRORS;
-    _resolvedUnitState = CacheState.ERROR;
-    _resolvedUnit = null;
-    _resolutionErrorsState = CacheState.ERROR;
-    _resolutionErrors = AnalysisError.NO_ERRORS;
-    recordVerificationError();
-    if (_nextState != null) {
-      _nextState.recordResolutionErrorsInAllLibraries();
-    }
-  }
-
-  /**
-   * Record that an in-process parse has stopped without recording results because the results
-   * were invalidated before they could be recorded.
-   */
-  void recordResolutionNotInProcess() {
-    if (_resolvedUnitState == CacheState.IN_PROCESS) {
-      _resolvedUnitState = CacheState.INVALID;
-    }
-    if (_resolutionErrorsState == CacheState.IN_PROCESS) {
-      _resolutionErrorsState = CacheState.INVALID;
-    }
-    if (_verificationErrorsState == CacheState.IN_PROCESS) {
-      _verificationErrorsState = CacheState.INVALID;
-    }
-    if (_hintsState == CacheState.IN_PROCESS) {
-      _hintsState = CacheState.INVALID;
-    }
-    if (_nextState != null) {
-      _nextState.recordResolutionNotInProcess();
-    }
-  }
-
-  /**
-   * Record that an error occurred while attempting to generate errors and warnings for the source
-   * represented by this entry. This will set the state of all verification information as being
-   * in error.
-   */
-  void recordVerificationError() {
-    _verificationErrors = AnalysisError.NO_ERRORS;
-    _verificationErrorsState = CacheState.ERROR;
-    recordHintError();
-  }
-
-  /**
-   * Write a textual representation of the difference between the old entry and this entry to the
-   * given string builder.
-   *
-   * @param builder the string builder to which the difference is to be written
-   * @param oldEntry the entry that was replaced by this entry
-   * @return `true` if some difference was written
-   */
-  bool writeDiffOn(JavaStringBuilder builder, bool needsSeparator, DartEntry oldEntry) {
-    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.RESOLVED_UNIT, _resolvedUnitState, "resolvedUnit");
-    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.RESOLUTION_ERRORS, _resolutionErrorsState, "resolutionErrors");
-    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.VERIFICATION_ERRORS, _verificationErrorsState, "verificationErrors");
-    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.HINTS, _hintsState, "hints");
-    return needsSeparator;
-  }
-
-  /**
-   * Write a textual representation of this state to the given builder. The result will only be
-   * used for debugging purposes.
-   *
-   * @param builder the builder to which the text should be written
-   */
-  void writeOn(JavaStringBuilder builder) {
-    if (_librarySource != null) {
-      builder.append("; builtUnit = ");
-      builder.append(_builtUnitState);
-      builder.append("; buildElementErrors = ");
-      builder.append(_buildElementErrorsState);
-      builder.append("; resolvedUnit = ");
-      builder.append(_resolvedUnitState);
-      builder.append("; resolutionErrors = ");
-      builder.append(_resolutionErrorsState);
-      builder.append("; verificationErrors = ");
-      builder.append(_verificationErrorsState);
-      builder.append("; hints = ");
-      builder.append(_hintsState);
-      if (_nextState != null) {
-        _nextState.writeOn(builder);
-      }
-    }
-  }
-
-  /**
-   * Write a textual representation of the difference between the state of the specified data
-   * between the old entry and this entry to the given string builder.
-   *
-   * @param builder the string builder to which the difference is to be written
-   * @param needsSeparator `true` if any data that is written
-   * @param oldEntry the entry that was replaced by this entry
-   * @param descriptor the descriptor defining the data whose state is being compared
-   * @param label the label used to describe the state
-   * @return `true` if some difference was written
-   */
-  bool writeStateDiffOn(JavaStringBuilder builder, bool needsSeparator, SourceEntry oldEntry, DataDescriptor descriptor, CacheState newState, String label) {
-    CacheState oldState = (oldEntry as DartEntryImpl).getStateInLibrary(descriptor, _librarySource);
-    if (oldState != newState) {
-      if (needsSeparator) {
-        builder.append("; ");
-      }
-      builder.append(label);
-      builder.append(" = ");
-      builder.append(oldState);
-      builder.append(" -> ");
-      builder.append(newState);
-      return true;
-    }
-    return needsSeparator;
-  }
-}
-
-/**
  * Instances of the class `DataDescriptor` are immutable constants representing data that can
  * be stored in the cache.
  */
 class DataDescriptor<E> {
   /**
    * The name of the descriptor, used for debugging purposes.
    */
   final String _name;
 
   /**
@@ skipping 113 matching lines @@
    * @param directive the directive to be verified
    * @param errorListener the error listener to which errors should be reported
    */
   static void validateReferencedSource(AnalysisContext context, Source librarySource, UriBasedDirective directive, AnalysisErrorListener errorListener) {
     Source source = directive.source;
     if (source != null) {
       if (context.exists(source)) {
         return;
       }
     } else {
-      // Don't report errors already reported by ParseDartTask#resolveDirective
+      // Don't report errors already reported by ParseDartTask.resolveDirective
       if (directive.validate() != null) {
         return;
       }
     }
     StringLiteral uriLiteral = directive.uri;
     errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.URI_DOES_NOT_EXIST, [directive.uriContent]));
   }
 
   /**
    * The source for which errors and warnings are to be produced.
@@ skipping 207 matching lines @@
    * Return the time at which the contents of the source that was parsed were last modified, or a
    * negative value if the task has not yet been performed or if an exception occurred.
    *
    * @return the time at which the contents of the source that was parsed were last modified
    */
   int get modificationTime => _modificationTime;
 
   /**
    * Return `true` if this task is complete. Unlike most tasks, this task is allowed to be
    * visited more than once in order to support asynchronous IO. If the task is not complete when it
-   * is visited synchronously as part of the [AnalysisTask#perform]
+   * is visited synchronously as part of the [AnalysisTask.perform]
    * method, it will be visited again, using the same visitor, when the IO operation has been
    * performed.
    *
    * @return `true` if this task is complete
    */
   bool get isComplete => _complete;
 
   @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;
     } 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.
+ * An `HtmlEntry` maintains the information cached by an analysis context about
+ * an individual HTML file.
  */
-abstract class HtmlEntry implements SourceEntry {
-  /**
-   * The data descriptor representing the information about an Angular application this source is
-   * used in.
-   */
-  static final DataDescriptor<AngularApplication> ANGULAR_APPLICATION = new DataDescriptor<AngularApplication>("HtmlEntry.ANGULAR_APPLICATION");
-
-  /**
-   * The data descriptor representing the information about an Angular component this source is used
-   * as template for.
-   */
-  static final DataDescriptor<AngularComponentElement> ANGULAR_COMPONENT = new DataDescriptor<AngularComponentElement>("HtmlEntry.ANGULAR_COMPONENT");
-
-  /**
-   * The data descriptor representing the information about an Angular application this source is
-   * entry point for.
-   */
-  static final DataDescriptor<AngularApplication> ANGULAR_ENTRY = new DataDescriptor<AngularApplication>("HtmlEntry.ANGULAR_ENTRY");
-
-  /**
-   * The data descriptor representing the errors reported during Angular resolution.
-   */
-  static final DataDescriptor<List<AnalysisError>> ANGULAR_ERRORS = new DataDescriptor<List<AnalysisError>>("HtmlEntry.ANGULAR_ERRORS");
-
-  /**
-   * The data descriptor representing the HTML element.
-   */
-  static final DataDescriptor<HtmlElement> ELEMENT = new DataDescriptor<HtmlElement>("HtmlEntry.ELEMENT");
-
-  /**
-   * The data descriptor representing the hints resulting from auditing the source.
-   */
-  static final DataDescriptor<List<AnalysisError>> HINTS = new DataDescriptor<List<AnalysisError>>("HtmlEntry.HINTS");
-
-  /**
-   * The data descriptor representing the errors resulting from parsing the source.
-   */
-  static final DataDescriptor<List<AnalysisError>> PARSE_ERRORS = new DataDescriptor<List<AnalysisError>>("HtmlEntry.PARSE_ERRORS");
-
-  /**
-   * The data descriptor representing the parsed AST structure.
-   */
-  static final DataDescriptor<ht.HtmlUnit> PARSED_UNIT = new DataDescriptor<ht.HtmlUnit>("HtmlEntry.PARSED_UNIT");
-
-  /**
-   * The data descriptor representing the resolved AST structure.
-   */
-  static final DataDescriptor<ht.HtmlUnit> RESOLVED_UNIT = new DataDescriptor<ht.HtmlUnit>("HtmlEntry.RESOLVED_UNIT");
-
-  /**
-   * The data descriptor representing the list of referenced libraries.
-   */
-  static final DataDescriptor<List<Source>> REFERENCED_LIBRARIES = new DataDescriptor<List<Source>>("HtmlEntry.REFERENCED_LIBRARIES");
-
-  /**
-   * The data descriptor representing the errors resulting from resolving the source.
-   */
-  static final DataDescriptor<List<AnalysisError>> RESOLUTION_ERRORS = new DataDescriptor<List<AnalysisError>>("HtmlEntry.RESOLUTION_ERRORS");
-
-  /**
-   * The data descriptor representing the status of Polymer elements in the source.
-   */
-  static final DataDescriptor<List<AnalysisError>> POLYMER_BUILD_ERRORS = new DataDescriptor<List<AnalysisError>>("HtmlEntry.POLYMER_BUILD_ERRORS");
-
-  /**
-   * The data descriptor representing the errors reported during Polymer resolution.
-   */
-  static final DataDescriptor<List<AnalysisError>> POLYMER_RESOLUTION_ERRORS = new DataDescriptor<List<AnalysisError>>("HtmlEntry.POLYMER_RESOLUTION_ERRORS");
-
-  /**
-   * Return all of the errors associated with the compilation unit that are currently cached.
-   *
-   * @return all of the errors associated with the compilation unit
-   */
-  List<AnalysisError> get allErrors;
-
-  /**
-   * Return a valid parsed unit, either an unresolved AST structure or the result of resolving the
-   * AST structure, or `null` if there is no parsed unit available.
-   *
-   * @return a valid parsed unit
-   */
-  ht.HtmlUnit get anyParsedUnit;
-}
-
-/**
- * Instances of the class `HtmlEntryImpl` implement an [HtmlEntry].
- */
-class HtmlEntryImpl extends SourceEntryImpl implements HtmlEntry {
+class HtmlEntry extends SourceEntry {
   /**
    * The state of the cached parsed (but not resolved) HTML unit.
    */
   CacheState _parsedUnitState = CacheState.INVALID;
 
   /**
    * The parsed HTML unit, or `null` if the parsed HTML unit is not currently cached.
    */
   ht.HtmlUnit _parsedUnit;
 
@@ skipping 118 matching lines @@
    */
   CacheState _polymerResolutionErrorsState = CacheState.INVALID;
 
   /**
    * The hints produced while performing Polymer resolution, or an empty array if the error are not
    * currently cached.
    */
   List<AnalysisError> _polymerResolutionErrors = AnalysisError.NO_ERRORS;
 
   /**
+   * The data descriptor representing the information about an Angular
+   * application this source is used in.
+   */
+  static final DataDescriptor<AngularApplication> ANGULAR_APPLICATION
+      = new DataDescriptor<AngularApplication>("HtmlEntry.ANGULAR_APPLICATION");
+
+  /**
+   * The data descriptor representing the information about an Angular component
+   * this source is used as template for.
+   */
+  static final DataDescriptor<AngularComponentElement> ANGULAR_COMPONENT
+      = new DataDescriptor<AngularComponentElement>("HtmlEntry.ANGULAR_COMPONENT");
+
+  /**
+   * The data descriptor representing the information about an Angular
+   * application for which this source is an entry point.
+   */
+  static final DataDescriptor<AngularApplication> ANGULAR_ENTRY
+      = new DataDescriptor<AngularApplication>("HtmlEntry.ANGULAR_ENTRY");
+
+  /**
+   * The data descriptor representing the errors reported during Angular
+   * resolution.
+   */
+  static final DataDescriptor<List<AnalysisError>> ANGULAR_ERRORS
+      = new DataDescriptor<List<AnalysisError>>("HtmlEntry.ANGULAR_ERRORS");
+
+  /**
+   * The data descriptor representing the HTML element.
+   */
+  static final DataDescriptor<HtmlElement> ELEMENT
+      = new DataDescriptor<HtmlElement>("HtmlEntry.ELEMENT");
+
+  /**
+   * The data descriptor representing the hints resulting from auditing the
+   * source.
+   */
+  static final DataDescriptor<List<AnalysisError>> HINTS
+      = new DataDescriptor<List<AnalysisError>>("HtmlEntry.HINTS");
+
+  /**
+   * The data descriptor representing the errors resulting from parsing the
+   * source.
+   */
+  static final DataDescriptor<List<AnalysisError>> PARSE_ERRORS
+      = new DataDescriptor<List<AnalysisError>>("HtmlEntry.PARSE_ERRORS");
+
+  /**
+   * The data descriptor representing the parsed AST structure.
+   */
+  static final DataDescriptor<ht.HtmlUnit> PARSED_UNIT
+      = new DataDescriptor<ht.HtmlUnit>("HtmlEntry.PARSED_UNIT");
+
+  /**
+   * The data descriptor representing the resolved AST structure.
+   */
+  static final DataDescriptor<ht.HtmlUnit> RESOLVED_UNIT
+      = new DataDescriptor<ht.HtmlUnit>("HtmlEntry.RESOLVED_UNIT");
+
+  /**
+   * The data descriptor representing the list of referenced libraries.
+   */
+  static final DataDescriptor<List<Source>> REFERENCED_LIBRARIES
+      = new DataDescriptor<List<Source>>("HtmlEntry.REFERENCED_LIBRARIES");
+
+  /**
+   * The data descriptor representing the errors resulting from resolving the
+   * source.
+   */
+  static final DataDescriptor<List<AnalysisError>> RESOLUTION_ERRORS
+      = new DataDescriptor<List<AnalysisError>>("HtmlEntry.RESOLUTION_ERRORS");
+
+  /**
+   * The data descriptor representing the status of Polymer elements in the
+   * source.
+   */
+  static final DataDescriptor<List<AnalysisError>> POLYMER_BUILD_ERRORS
+      = new DataDescriptor<List<AnalysisError>>("HtmlEntry.POLYMER_BUILD_ERRORS");
+
+  /**
+   * The data descriptor representing the errors reported during Polymer
+   * resolution.
+   */
+  static final DataDescriptor<List<AnalysisError>> POLYMER_RESOLUTION_ERRORS
+      = new DataDescriptor<List<AnalysisError>>("HtmlEntry.POLYMER_RESOLUTION_ERRORS");
+
+  /**
    * Flush any AST structures being maintained by this entry.
    */
   void flushAstStructures() {
     if (_parsedUnitState == CacheState.VALID) {
       _parsedUnitState = CacheState.FLUSHED;
       _parsedUnit = null;
     }
     if (_resolvedUnitState == CacheState.VALID) {
       _resolvedUnitState = CacheState.FLUSHED;
       _resolvedUnit = null;
     }
     if (_angularEntryState == CacheState.VALID) {
       _angularEntryState = CacheState.FLUSHED;
     }
     if (_angularErrorsState == CacheState.VALID) {
       _angularErrorsState = CacheState.FLUSHED;
     }
   }
 
-  @override
+  /**
+   * Return all of the errors associated with the compilation unit that are
+   * currently cached.
+   */
   List<AnalysisError> get allErrors {
     List<AnalysisError> errors = new List<AnalysisError>();
     if (_parseErrors != null) {
       for (AnalysisError error in _parseErrors) {
         errors.add(error);
       }
     }
     if (_resolutionErrors != null) {
       for (AnalysisError error in _resolutionErrors) {
         errors.add(error);
@@ skipping 18 matching lines @@
       for (AnalysisError error in _polymerResolutionErrors) {
         errors.add(error);
       }
     }
     if (errors.length == 0) {
       return AnalysisError.NO_ERRORS;
     }
     return new List.from(errors);
   }
 
-  @override
+  /**
+   * Return a valid parsed unit, either an unresolved AST structure or the
+   * result of resolving the AST structure, or `null` if there is no parsed unit
+   * available.
+   */
   ht.HtmlUnit get anyParsedUnit {
     if (_parsedUnitState == CacheState.VALID) {
       //      parsedUnitAccessed = true;
       return _parsedUnit;
     }
     if (_resolvedUnitState == CacheState.VALID) {
       //      resovledUnitAccessed = true;
       return _resolvedUnit;
     }
     return null;
@@ skipping 244 matching lines @@
       super.setValue(descriptor, value);
     }
   }
 
   @override
   bool get hasErrorState => super.hasErrorState || _parsedUnitState == CacheState.ERROR || _resolvedUnitState == CacheState.ERROR || _parseErrorsState == CacheState.ERROR || _resolutionErrorsState == CacheState.ERROR || _referencedLibrariesState == CacheState.ERROR || _elementState == CacheState.ERROR || _angularErrorsState == CacheState.ERROR || _hintsState == CacheState.ERROR || _polymerBuildErrorsState == CacheState.ERROR || _polymerResolutionErrorsState == CacheState.ERROR;
 
   @override
   bool writeDiffOn(JavaStringBuilder builder, SourceEntry oldEntry) {
     bool needsSeparator = super.writeDiffOn(builder, oldEntry);
-    if (oldEntry is! HtmlEntryImpl) {
+    if (oldEntry is! HtmlEntry) {
       if (needsSeparator) {
         builder.append("; ");
       }
       builder.append("entry type changed; was ${oldEntry.runtimeType.toString()}");
       return true;
     }
     needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, HtmlEntry.PARSE_ERRORS, "parseErrors");
     needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, HtmlEntry.PARSED_UNIT, "parsedUnit");
     needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, HtmlEntry.RESOLVED_UNIT, "resolvedUnit");
     needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, HtmlEntry.RESOLUTION_ERRORS, "resolutionErrors");
@@ skipping 36 matching lines @@
     builder.append(_polymerBuildErrorsState);
     builder.append("; polymerResolutionErrors = ");
     builder.append(_polymerResolutionErrorsState);
   }
 }
 
 /**
  * Instances of the class `IncrementalAnalysisCache` hold information used to perform
  * incremental analysis.
  *
- * @see AnalysisContextImpl#setChangedContents(Source, String, int, int, int)
+ * @see AnalysisContextImpl.setChangedContents(Source, String, int, int, int)
  */
 class IncrementalAnalysisCache {
   /**
    * Determine if the incremental analysis result can be cached for the next incremental analysis.
    *
    * @param cache the prior incremental analysis cache
    * @param unit the incrementally updated compilation unit
    * @return the cache used for incremental analysis or `null` if incremental analysis results
    *         cannot be cached for the next incremental analysis
    */
@@ skipping 30 matching lines @@
    * @param oldLength the length of the text being replaced
    * @param newLength the length of the replacement text
    * @param sourceEntry the cached entry for the given source or `null` if none
    * @return the cache used for incremental analysis or `null` if incremental analysis cannot
    *         be performed
    */
   static IncrementalAnalysisCache update(IncrementalAnalysisCache cache, Source source, String oldContents, String newContents, int offset, int oldLength, int newLength, SourceEntry sourceEntry) {
     // Determine the cache resolved unit
     Source librarySource = null;
     CompilationUnit unit = null;
-    if (sourceEntry is DartEntryImpl) {
-      DartEntryImpl dartEntry = sourceEntry;
+    if (sourceEntry is DartEntry) {
+      DartEntry dartEntry = sourceEntry;
       List<Source> librarySources = dartEntry.librariesContaining;
       if (librarySources.length == 1) {
         librarySource = librarySources[0];
         if (librarySource != null) {
           unit = dartEntry.getValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource);
         }
       }
     }
     // Create a new cache if there is not an existing cache or the source is different
     // or a new resolved compilation unit is available
@@ skipping 2627 matching lines @@
     return super.visitSimpleIdentifier(node);
   }
 
   @override
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     node.staticElement = null;
     return super.visitSuperConstructorInvocation(node);
   }
 }
 
+/**
+ * A `ResolutionState` maintains the information produced by resolving a
+ * compilation unit as part of a specific library.
+ */
+class ResolutionState {
+  /**
+   * The next resolution state or `null` if none.
+   */
+  ResolutionState _nextState;
+
+  /**
+   * The source for the defining compilation unit of the library that contains this unit. If this
+   * unit is the defining compilation unit for it's library, then this will be the source for this
+   * unit.
+   */
+  Source _librarySource;
+
+  /**
+   * The state of the cached compilation unit that contains references to the built element model.
+   */
+  CacheState _builtUnitState = CacheState.INVALID;
+
+  /**
+   * The compilation unit that contains references to the built element model, or `null` if
+   * that compilation unit is not currently cached.
+   */
+  CompilationUnit _builtUnit;
+
+  /**
+   * The state of the cached errors reported while building an element model.
+   */
+  CacheState _buildElementErrorsState = CacheState.INVALID;
+
+  /**
+   * The errors produced while building an element model, or an empty array if the errors are not
+   * currently cached.
+   */
+  List<AnalysisError> _buildElementErrors = AnalysisError.NO_ERRORS;
+
+  /**
+   * The state of the cached resolved compilation unit.
+   */
+  CacheState _resolvedUnitState = CacheState.INVALID;
+
+  /**
+   * The resolved compilation unit, or `null` if the resolved compilation unit is not
+   * currently cached.
+   */
+  CompilationUnit _resolvedUnit;
+
+  /**
+   * The state of the cached resolution errors.
+   */
+  CacheState _resolutionErrorsState = CacheState.INVALID;
+
+  /**
+   * The errors produced while resolving the compilation unit, or an empty array if the errors are
+   * not currently cached.
+   */
+  List<AnalysisError> _resolutionErrors = AnalysisError.NO_ERRORS;
+
+  /**
+   * The state of the cached verification errors.
+   */
+  CacheState _verificationErrorsState = CacheState.INVALID;
+
+  /**
+   * The errors produced while verifying the compilation unit, or an empty array if the errors are
+   * not currently cached.
+   */
+  List<AnalysisError> _verificationErrors = AnalysisError.NO_ERRORS;
+
+  /**
+   * The state of the cached hints.
+   */
+  CacheState _hintsState = CacheState.INVALID;
+
+  /**
+   * The hints produced while auditing the compilation unit, or an empty array if the hints are
+   * not currently cached.
+   */
+  List<AnalysisError> _hints = AnalysisError.NO_ERRORS;
+
+  /**
+   * Flush any AST structures being maintained by this state.
+   */
+  void flushAstStructures() {
+    if (_builtUnitState == CacheState.VALID) {
+      _builtUnitState = CacheState.FLUSHED;
+      _builtUnit = null;
+    }
+    if (_resolvedUnitState == CacheState.VALID) {
+      _resolvedUnitState = CacheState.FLUSHED;
+      _resolvedUnit = null;
+    }
+    if (_nextState != null) {
+      _nextState.flushAstStructures();
+    }
+  }
+
+  bool get hasErrorState => _builtUnitState == CacheState.ERROR || _buildElementErrorsState == CacheState.ERROR || _resolvedUnitState == CacheState.ERROR || _resolutionErrorsState == CacheState.ERROR || _verificationErrorsState == CacheState.ERROR || _hintsState == CacheState.ERROR || (_nextState != null && _nextState.hasErrorState);
+
+  /**
+   * Invalidate all of the resolution information associated with the compilation unit.
+   */
+  void invalidateAllResolutionInformation() {
+    _nextState = null;
+    _librarySource = null;
+    _builtUnitState = CacheState.INVALID;
+    _builtUnit = null;
+    _buildElementErrorsState = CacheState.INVALID;
+    _buildElementErrors = AnalysisError.NO_ERRORS;
+    _resolvedUnitState = CacheState.INVALID;
+    _resolvedUnit = null;
+    _resolutionErrorsState = CacheState.INVALID;
+    _resolutionErrors = AnalysisError.NO_ERRORS;
+    _verificationErrorsState = CacheState.INVALID;
+    _verificationErrors = AnalysisError.NO_ERRORS;
+    _hintsState = CacheState.INVALID;
+    _hints = AnalysisError.NO_ERRORS;
+  }
+
+  /**
+   * Record that an error occurred while attempting to build the element model for the source
+   * represented by this state.
+   */
+  void recordBuildElementError() {
+    _builtUnitState = CacheState.ERROR;
+    _builtUnit = null;
+    _buildElementErrorsState = CacheState.ERROR;
+    _buildElementErrors = AnalysisError.NO_ERRORS;
+    recordResolutionError();
+  }
+
+  /**
+   * Record that an error occurred while attempting to generate hints for the source represented
+   * by this entry. This will set the state of all verification information as being in error.
+   */
+  void recordHintError() {
+    _hints = AnalysisError.NO_ERRORS;
+    _hintsState = CacheState.ERROR;
+  }
+
+  /**
+   * Record that an error occurred while attempting to resolve the source represented by this
+   * state.
+   */
+  void recordResolutionError() {
+    _resolvedUnitState = CacheState.ERROR;
+    _resolvedUnit = null;
+    _resolutionErrorsState = CacheState.ERROR;
+    _resolutionErrors = AnalysisError.NO_ERRORS;
+    recordVerificationError();
+  }
+
+  /**
+   * Record that an error occurred while attempting to scan or parse the entry represented by this
+   * entry. This will set the state of all resolution-based information as being in error, but
+   * will not change the state of any parse results.
+   */
+  void recordResolutionErrorsInAllLibraries() {
+    _builtUnitState = CacheState.ERROR;
+    _builtUnit = null;
+    _buildElementErrorsState = CacheState.ERROR;
+    _buildElementErrors = AnalysisError.NO_ERRORS;
+    _resolvedUnitState = CacheState.ERROR;
+    _resolvedUnit = null;
+    _resolutionErrorsState = CacheState.ERROR;
+    _resolutionErrors = AnalysisError.NO_ERRORS;
+    recordVerificationError();
+    if (_nextState != null) {
+      _nextState.recordResolutionErrorsInAllLibraries();
+    }
+  }
+
+  /**
+   * Record that an in-process parse has stopped without recording results because the results
+   * were invalidated before they could be recorded.
+   */
+  void recordResolutionNotInProcess() {
+    if (_resolvedUnitState == CacheState.IN_PROCESS) {
+      _resolvedUnitState = CacheState.INVALID;
+    }
+    if (_resolutionErrorsState == CacheState.IN_PROCESS) {
+      _resolutionErrorsState = CacheState.INVALID;
+    }
+    if (_verificationErrorsState == CacheState.IN_PROCESS) {
+      _verificationErrorsState = CacheState.INVALID;
+    }
+    if (_hintsState == CacheState.IN_PROCESS) {
+      _hintsState = CacheState.INVALID;
+    }
+    if (_nextState != null) {
+      _nextState.recordResolutionNotInProcess();
+    }
+  }
+
+  /**
+   * Record that an error occurred while attempting to generate errors and warnings for the source
+   * represented by this entry. This will set the state of all verification information as being
+   * in error.
+   */
+  void recordVerificationError() {
+    _verificationErrors = AnalysisError.NO_ERRORS;
+    _verificationErrorsState = CacheState.ERROR;
+    recordHintError();
+  }
+
+  /**
+   * Write a textual representation of the difference between the old entry and this entry to the
+   * given string builder.
+   *
+   * @param builder the string builder to which the difference is to be written
+   * @param oldEntry the entry that was replaced by this entry
+   * @return `true` if some difference was written
+   */
+  bool writeDiffOn(JavaStringBuilder builder, bool needsSeparator, DartEntry oldEntry) {
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.RESOLVED_UNIT, _resolvedUnitState, "resolvedUnit");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.RESOLUTION_ERRORS, _resolutionErrorsState, "resolutionErrors");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.VERIFICATION_ERRORS, _verificationErrorsState, "verificationErrors");
+    needsSeparator = writeStateDiffOn(builder, needsSeparator, oldEntry, DartEntry.HINTS, _hintsState, "hints");
+    return needsSeparator;
+  }
+
+  /**
+   * Write a textual representation of this state to the given builder. The result will only be
+   * used for debugging purposes.
+   *
+   * @param builder the builder to which the text should be written
+   */
+  void writeOn(JavaStringBuilder builder) {
+    if (_librarySource != null) {
+      builder.append("; builtUnit = ");
+      builder.append(_builtUnitState);
+      builder.append("; buildElementErrors = ");
+      builder.append(_buildElementErrorsState);
+      builder.append("; resolvedUnit = ");
+      builder.append(_resolvedUnitState);
+      builder.append("; resolutionErrors = ");
+      builder.append(_resolutionErrorsState);
+      builder.append("; verificationErrors = ");
+      builder.append(_verificationErrorsState);
+      builder.append("; hints = ");
+      builder.append(_hintsState);
+      if (_nextState != null) {
+        _nextState.writeOn(builder);
+      }
+    }
+  }
+
+  /**
+   * Write a textual representation of the difference between the state of the specified data
+   * between the old entry and this entry to the given string builder.
+   *
+   * @param builder the string builder to which the difference is to be written
+   * @param needsSeparator `true` if any data that is written
+   * @param oldEntry the entry that was replaced by this entry
+   * @param descriptor the descriptor defining the data whose state is being compared
+   * @param label the label used to describe the state
+   * @return `true` if some difference was written
+   */
+  bool writeStateDiffOn(JavaStringBuilder builder, bool needsSeparator, SourceEntry oldEntry, DataDescriptor descriptor, CacheState newState, String label) {
+    CacheState oldState = (oldEntry as DartEntry).getStateInLibrary(descriptor, _librarySource);
+    if (oldState != newState) {
+      if (needsSeparator) {
+        builder.append("; ");
+      }
+      builder.append(label);
+      builder.append(" = ");
+      builder.append(oldState);
+      builder.append(" -> ");
+      builder.append(newState);
+      return true;
+    }
+    return needsSeparator;
+  }
+}
+
 /**
  * Instances of the class `ResolvableCompilationUnit` represent a compilation unit that is not
  * referenced by any other objects and for which we have modification stamp information. It is used
  * by the [LibraryResolver] to resolve a library.
  */
 class ResolvableCompilationUnit extends TimestampedData<CompilationUnit> {
   /**
    * The source of the compilation unit.
    */
   final Source source;
@@ skipping 737 matching lines @@
    * @param maxCacheSize the maximum number of sources for which AST structures should be kept in
    *          the cache
    */
   SdkCachePartition(InternalAnalysisContext context, int maxCacheSize) : super(context, maxCacheSize, DefaultRetentionPolicy.POLICY);
 
   @override
   bool contains(Source source) => source.isInSystemLibrary;
 }
 
 /**
- * The interface `SourceEntry` defines the behavior of objects that maintain the information
- * cached by an analysis context about an individual source, no matter what kind of source it is.
- *
- * Source entries should be treated as if they were immutable unless a writable copy of the entry
- * has been obtained and has not yet been made visible to other threads.
+ * A `SourceEntry` maintains the information cached by an analysis context about
+ * an individual source, no matter what kind of source it is.
  */
 abstract class SourceEntry {
   /**
-   * The data descriptor representing the contents of the source.
-   */
-  static final DataDescriptor<String> CONTENT = new DataDescriptor<String>("DartEntry.CONTENT");
-
-  /**
-   * 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
-   */
-  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;
-
-  /**
-   * Return the kind of the source, or `null` if the kind is not currently cached.
-   *
-   * @return the kind of the source
-   */
-  SourceKind get kind;
-
-  /**
-   * Return the most recent time at which the state of the source matched the state represented by
-   * this entry.
-   *
-   * @return the modification time of this entry
-   */
-  int get modificationTime;
-
-  /**
-   * Return the state of the data represented by the given descriptor.
-   *
-   * @param descriptor the descriptor representing the data whose state is to be returned
-   * @return the state of the data represented by the given descriptor
-   */
-  CacheState getState(DataDescriptor descriptor);
-
-  /**
-   * Return the value of the data represented by the given descriptor, or `null` if the data
-   * represented by the descriptor is not in the cache.
-   *
-   * @param descriptor the descriptor representing which data is to be returned
-   * @return the value of the data represented by the given descriptor
-   */
-  Object getValue(DataDescriptor descriptor);
-}
-
-/**
- * Instances of the abstract class `SourceEntryImpl` implement the behavior common to all
- * [SourceEntry].
- */
-abstract class SourceEntryImpl implements SourceEntry {
-  /**
-   * The most recent time at which the state of the source matched the state represented by this
-   * entry.
+   * The most recent time at which the state of the source matched the state
+   * represented by this entry.
    */
   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].
+   * The exception that caused one or more values to have a state of
+   * [CacheState.ERROR].
    */
   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;
 
   /**
    * The state of the cached line information.
    */
   CacheState _lineInfoState = CacheState.INVALID;
 
   /**
-   * The line information computed for the source, or `null` if the line information is not
-   * currently cached.
+   * The line information computed for the source, or `null` if the line
+   * information is not currently cached.
    */
   LineInfo _lineInfo;
 
   /**
-   * The index of the flag indicating whether the source was explicitly added to the context or
-   * whether the source was implicitly added because it was referenced by another source.
+   * The data descriptor representing the contents of the source.
+   */
+  static final DataDescriptor<String> CONTENT
+      = new DataDescriptor<String>("SourceEntry.CONTENT");
+
+  /**
+   * The data descriptor representing the line information.
+   */
+  static final DataDescriptor<LineInfo> LINE_INFO
+      = new DataDescriptor<LineInfo>("SourceEntry.LINE_INFO");
+
+  /**
+   * The index of the flag indicating whether the source was explicitly added to
+   * the context or whether the source was implicitly added because it was
+   * referenced by another source.
    */
   static int _EXPLICITLY_ADDED_FLAG = 0;
 
   /**
    * Fix the state of the [exception] to match the current state of the entry.
    */
   void fixExceptionState() {
     if (hasErrorState) {
       if (_exception == null) {
         //
@@ skipping 15 matching lines @@
    * @param oldEntry the entry being diff'd with this entry
    * @return a textual representation of the difference
    */
   String getDiff(SourceEntry oldEntry) {
     JavaStringBuilder builder = new JavaStringBuilder();
     writeDiffOn(builder, oldEntry);
     return builder.toString();
   }
 
   /**
-   * 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
+   * Return the exception that caused one or more values to have a state of
+   * [CacheState.ERROR].
    */
-  @override
   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
+   * 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.
    */
-  @override
   bool get explicitlyAdded => getFlag(_EXPLICITLY_ADDED_FLAG);
 
-  @override
+  /**
+   * Return the kind of the source, or `null` if the kind is not currently
+   * cached.
+   */
+  SourceKind get kind;
+
+  /**
+   * Return the most recent time at which the state of the source matched the
+   * state represented by this entry.
+   */
   int get modificationTime => _modificationTime;
 
-  @override
+  /**
+   * Return the state of the data represented by the given [descriptor].
+   */
   CacheState getState(DataDescriptor descriptor) {
     if (identical(descriptor, SourceEntry.CONTENT)) {
       return _contentState;
     } else if (identical(descriptor, SourceEntry.LINE_INFO)) {
       return _lineInfoState;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
 
-  @override
+  /**
+   * Return the value of the data represented by the given [descriptor], or
+   * `null` if the data represented by the descriptor is not in the cache.
+   */
   Object getValue(DataDescriptor descriptor) {
     if (identical(descriptor, SourceEntry.CONTENT)) {
       return _content;
     } else if (identical(descriptor, SourceEntry.LINE_INFO)) {
       return _lineInfo;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
 
@@ skipping 27 matching lines @@
    *
    * @param exception the exception that shows where the error occurred
    */
   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
+   * Set whether the source was explicitly added to the context to match the
+   * given value.
    */
   void set explicitlyAdded(bool explicitlyAdded) {
     setFlag(_EXPLICITLY_ADDED_FLAG, explicitlyAdded);
   }
 
   /**
-   * Set the most recent time at which the state of the source matched the state represented by this
-   * entry to the given time.
-   *
-   * @param time the new modification time of this entry
+   * Set the most recent time at which the state of the source matched the state
+   * represented by this entry to the given time.
    */
   void set modificationTime(int time) {
     _modificationTime = time;
   }
 
   /**
    * Set the state of the data represented by the given descriptor to the given state.
    *
    * @param descriptor the descriptor representing the data whose state is to be set
    * @param the new state of the data represented by the given descriptor
@@ skipping 48 matching lines @@
 
   /**
    * Return the value of the flag with the given index.
    *
    * @param index the index of the flag whose value is to be returned
    * @return the value of the flag with the given index
    */
   bool getFlag(int index) => BooleanArray.get(_flags, index);
 
   /**
-   * Return `true` if the state of any data value is [CacheState#ERROR].
+   * Return `true` if the state of any data value is [CacheState.ERROR].
    *
-   * @return `true` if the state of any data value is [CacheState#ERROR]
+   * @return `true` if the state of any data value is [CacheState.ERROR]
    */
   bool get hasErrorState => _contentState == CacheState.ERROR || _lineInfoState == CacheState.ERROR;
 
   /**
-   * Set the exception that caused one or more values to have a state of [CacheState#ERROR] to
-   * the given exception.
-   *
-   * @param exception the exception that caused one or more values to be uncomputable
+   * Set the exception that caused one or more values to have a state of
+   * [CacheState.ERROR] to the given [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.
@@ skipping 413 matching lines @@
     _index++;
     if (_index >= _manager._workQueues[_queueIndex].length) {
       _index = 0;
       _queueIndex++;
       while (_queueIndex < _manager._workQueues.length && _manager._workQueues[_queueIndex].isEmpty) {
         _queueIndex++;
       }
     }
   }
 }