Allow the contents of the analysis cache to be inspected via html debugging.

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:math" as math;
@@ skipping 1662 matching lines @@
       return false;
     }
     if (_contentCache.getContents(source) != null) {
       return true;
     }
     return source.exists();
   }
 
   @override
   AngularApplication getAngularApplicationWithHtml(Source htmlSource) {
-    SourceEntry sourceEntry = _getReadableSourceEntryOrNull(htmlSource);
+    SourceEntry sourceEntry = getReadableSourceEntryOrNull(htmlSource);
     if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       AngularApplication application =
           htmlEntry.getValue(HtmlEntry.ANGULAR_APPLICATION);
       if (application != null) {
         return application;
       }
       return htmlEntry.getValue(HtmlEntry.ANGULAR_ENTRY);
     }
     return null;
@@ skipping 57 matching lines @@
       if (AnalysisEngine.isHtmlFileName(sourceName)) {
         return computeHtmlElement(source);
       }
     } on AnalysisException catch (exception) {
     }
     return null;
   }
 
   @override
   AnalysisErrorInfo getErrors(Source source) {
-    SourceEntry sourceEntry = _getReadableSourceEntryOrNull(source);
+    SourceEntry sourceEntry = getReadableSourceEntryOrNull(source);
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       return new AnalysisErrorInfoImpl(
           dartEntry.allErrors,
           dartEntry.getValue(SourceEntry.LINE_INFO));
     } else if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       return new AnalysisErrorInfoImpl(
           htmlEntry.allErrors,
           htmlEntry.getValue(SourceEntry.LINE_INFO));
     }
     return new AnalysisErrorInfoImpl(AnalysisError.NO_ERRORS, null);
   }
 
   @override
   HtmlElement getHtmlElement(Source source) {
-    SourceEntry sourceEntry = _getReadableSourceEntryOrNull(source);
+    SourceEntry sourceEntry = getReadableSourceEntryOrNull(source);
     if (sourceEntry is HtmlEntry) {
       return sourceEntry.getValue(HtmlEntry.ELEMENT);
     }
     return null;
   }
 
   @override
   List<Source> getHtmlFilesReferencing(Source source) {
     SourceKind sourceKind = getKindOf(source);
     if (sourceKind == null) {
@@ skipping 30 matching lines @@
       break;
     }
     if (htmlSources.isEmpty) {
       return Source.EMPTY_ARRAY;
     }
     return htmlSources;
   }
 
   @override
   SourceKind getKindOf(Source source) {
-    SourceEntry sourceEntry = _getReadableSourceEntryOrNull(source);
+    SourceEntry sourceEntry = getReadableSourceEntryOrNull(source);
     if (sourceEntry == null) {
       return SourceKind.UNKNOWN;
     }
     return sourceEntry.kind;
   }
 
   @override
   List<Source> getLibrariesContaining(Source source) {
-    SourceEntry sourceEntry = _getReadableSourceEntryOrNull(source);
+    SourceEntry sourceEntry = getReadableSourceEntryOrNull(source);
     if (sourceEntry is DartEntry) {
       return sourceEntry.containingLibraries;
     }
     return Source.EMPTY_ARRAY;
   }
 
   @override
   List<Source> getLibrariesDependingOn(Source librarySource) {
     List<Source> dependentLibraries = new List<Source>();
     MapIterator<Source, SourceEntry> iterator = _cache.iterator();
@@ skipping 13 matching lines @@
       }
     }
     if (dependentLibraries.isEmpty) {
       return Source.EMPTY_ARRAY;
     }
     return dependentLibraries;
   }
 
   @override
   List<Source> getLibrariesReferencedFromHtml(Source htmlSource) {
-    SourceEntry sourceEntry = _getReadableSourceEntryOrNull(htmlSource);
+    SourceEntry sourceEntry = getReadableSourceEntryOrNull(htmlSource);
     if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       return htmlEntry.getValue(HtmlEntry.REFERENCED_LIBRARIES);
     }
     return Source.EMPTY_ARRAY;
   }
 
   @override
   LibraryElement getLibraryElement(Source source) {
-    SourceEntry sourceEntry = _getReadableSourceEntryOrNull(source);
+    SourceEntry sourceEntry = getReadableSourceEntryOrNull(source);
     if (sourceEntry is DartEntry) {
       return sourceEntry.getValue(DartEntry.ELEMENT);
     }
     return null;
   }
 
   @override
   LineInfo getLineInfo(Source source) {
-    SourceEntry sourceEntry = _getReadableSourceEntryOrNull(source);
+    SourceEntry sourceEntry = getReadableSourceEntryOrNull(source);
     if (sourceEntry != null) {
       return sourceEntry.getValue(SourceEntry.LINE_INFO);
     }
     return null;
   }
 
   @override
   int getModificationStamp(Source source) {
     int stamp = _contentCache.getModificationStamp(source);
     if (stamp != null) {
@@ skipping 26 matching lines @@
                 null));
         return null;
       }
       if (identical(dartEntry.getValue(DartEntry.ELEMENT), library)) {
         dartEntry.setValue(DartEntry.PUBLIC_NAMESPACE, namespace);
       }
     }
     return namespace;
   }
 
+  /**
+   * Return the cache entry associated with the given source, or `null` if there is no entry
+   * associated with the source.
+   *
+   * @param source the source for which a cache entry is being sought
+   * @return the source cache entry associated with the given source
+   */
+  SourceEntry getReadableSourceEntryOrNull(Source source) => _cache.get(source);
+
   @override
   CompilationUnit getResolvedCompilationUnit(Source unitSource,
       LibraryElement library) {
     if (library == null) {
       return null;
     }
     return getResolvedCompilationUnit2(unitSource, library.source);
   }
 
   @override
   CompilationUnit getResolvedCompilationUnit2(Source unitSource,
       Source librarySource) {
-    SourceEntry sourceEntry = _getReadableSourceEntryOrNull(unitSource);
+    SourceEntry sourceEntry = getReadableSourceEntryOrNull(unitSource);
     if (sourceEntry is DartEntry) {
       return sourceEntry.getValueInLibrary(
           DartEntry.RESOLVED_UNIT,
           librarySource);
     }
     return null;
   }
 
   @override
   ht.HtmlUnit getResolvedHtmlUnit(Source htmlSource) {
-    SourceEntry sourceEntry = _getReadableSourceEntryOrNull(htmlSource);
+    SourceEntry sourceEntry = getReadableSourceEntryOrNull(htmlSource);
     if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       return htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT);
     }
     return null;
   }
 
   @override
   bool isClientLibrary(Source librarySource) {
     SourceEntry sourceEntry = _getReadableSourceEntry(librarySource);
@@ skipping 344 matching lines @@
   void setContents(Source source, String contents) {
     if (_contentsChanged(source, contents)) {
       _onSourcesChangedController.add(
           new SourcesChangedEvent.changedContent(source, contents));
     }
   }
 
   @override
   void visitCacheItems(void callback(Source source, SourceEntry dartEntry,
       DataDescriptor rowDesc, CacheState state)) {
-    void handleCacheItem(Source source, SourceEntry dartEntry,
-        DataDescriptor descriptor) {
-      callback(source, dartEntry, descriptor, dartEntry.getState(descriptor));
-    }
-    void handleCacheItemInLibrary(DartEntry dartEntry, Source librarySource,
-        DataDescriptor descriptor) {
-      callback(
-          librarySource,
-          dartEntry,
-          descriptor,
-          dartEntry.getStateInLibrary(descriptor, librarySource));
-    }
-
     bool hintsEnabled = _options.hint;
     MapIterator<Source, SourceEntry> iterator = _cache.iterator();
     while (iterator.moveNext()) {
       Source source = iterator.key;
       SourceEntry sourceEntry = iterator.value;
-      if (sourceEntry is DartEntry) {
-        DartEntry dartEntry = sourceEntry;
-        SourceKind kind = dartEntry.getValue(DartEntry.SOURCE_KIND);
-        // get library independent values
-        handleCacheItem(source, dartEntry, SourceEntry.CONTENT);
-        handleCacheItem(source, dartEntry, SourceEntry.LINE_INFO);
-        // The list of containing libraries is always valid, so the state isn't
-        // interesting.
-//        handleCacheItem(source, dartEntry, DartEntry.CONTAINING_LIBRARIES);
-        handleCacheItem(source, dartEntry, DartEntry.PARSE_ERRORS);
-        handleCacheItem(source, dartEntry, DartEntry.PARSED_UNIT);
-        handleCacheItem(source, dartEntry, DartEntry.SCAN_ERRORS);
-        handleCacheItem(source, dartEntry, DartEntry.SOURCE_KIND);
-        handleCacheItem(source, dartEntry, DartEntry.TOKEN_STREAM);
-        if (kind == SourceKind.LIBRARY) {
-          handleCacheItem(source, dartEntry, DartEntry.ELEMENT);
-          handleCacheItem(source, dartEntry, DartEntry.EXPORTED_LIBRARIES);
-          handleCacheItem(source, dartEntry, DartEntry.IMPORTED_LIBRARIES);
-          handleCacheItem(source, dartEntry, DartEntry.INCLUDED_PARTS);
-          handleCacheItem(source, dartEntry, DartEntry.IS_CLIENT);
-          handleCacheItem(source, dartEntry, DartEntry.IS_LAUNCHABLE);
+      for (DataDescriptor descriptor in sourceEntry.descriptors) {
+        if (descriptor == DartEntry.SOURCE_KIND) {
+          // The source kind is always valid, so the state isn't interesting.
+          continue;
+        } else if (descriptor == DartEntry.CONTAINING_LIBRARIES) {
+          // The list of containing libraries is always valid, so the state isn't
+          // interesting.
+          continue;
+        } else if (descriptor == DartEntry.PUBLIC_NAMESPACE) {
           // The public namespace isn't computed by performAnalysisTask()
           // and therefore isn't interesting.
-          //handleCacheItem(key, dartEntry, DartEntry.PUBLIC_NAMESPACE);
+          continue;
+        } else if (descriptor == HtmlEntry.ANGULAR_APPLICATION ||
+            descriptor == HtmlEntry.ANGULAR_COMPONENT ||
+            descriptor == HtmlEntry.ANGULAR_ENTRY ||
+            descriptor == HtmlEntry.ANGULAR_ERRORS ||
+            descriptor == HtmlEntry.POLYMER_BUILD_ERRORS ||
+            descriptor == HtmlEntry.POLYMER_RESOLUTION_ERRORS) {
+          // These values are not currently being computed, so their state is
+          // not interesting.
+          continue;
+        } else if (descriptor == HtmlEntry.HINTS) {
+          // We are not currently recording any hints related to HTML.
+          continue;
         }
+        callback(
+            source,
+            sourceEntry,
+            descriptor,
+            sourceEntry.getState(descriptor));
+      }
+      if (sourceEntry is DartEntry) {
         // get library-specific values
         List<Source> librarySources = getLibrariesContaining(source);
         for (Source librarySource in librarySources) {
-          // These values are not currently being computed, so their state is
-          // not interesting.
-//          handleCacheItemInLibrary(dartEntry, librarySource, DartEntry.ANGULAR_ERRORS);
-//          handleCacheItemInLibrary(dartEntry, librarySource, DartEntry.BUILT_ELEMENT);
-//          handleCacheItemInLibrary(dartEntry, librarySource, DartEntry.BUILT_UNIT);
-          handleCacheItemInLibrary(
-              dartEntry,
-              librarySource,
-              DartEntry.RESOLUTION_ERRORS);
-          handleCacheItemInLibrary(
-              dartEntry,
-              librarySource,
-              DartEntry.RESOLVED_UNIT);
-          if (_generateSdkErrors || !source.isInSystemLibrary) {
-            handleCacheItemInLibrary(
-                dartEntry,
+          for (DataDescriptor descriptor in sourceEntry.libraryDescriptors) {
+            if (descriptor == DartEntry.ANGULAR_ERRORS ||
+                descriptor == DartEntry.BUILT_ELEMENT ||
+                descriptor == DartEntry.BUILT_UNIT) {
+              // These values are not currently being computed, so their state is
+              // not interesting.
+              continue;
+            } else if (source.isInSystemLibrary &&
+                !_generateSdkErrors &&
+                (descriptor == DartEntry.VERIFICATION_ERRORS ||
+                    descriptor == DartEntry.HINTS)) {
+              continue;
+            } else if (!hintsEnabled && descriptor == DartEntry.HINTS) {
+              continue;
+            }
+            callback(
                 librarySource,
-                DartEntry.VERIFICATION_ERRORS);
-            if (hintsEnabled) {
-              handleCacheItemInLibrary(
-                  dartEntry,
-                  librarySource,
-                  DartEntry.HINTS);
-            }
+                sourceEntry,
+                descriptor,
+                sourceEntry.getStateInLibrary(descriptor, librarySource));
           }
         }
-      } else if (sourceEntry is HtmlEntry) {
-        HtmlEntry htmlEntry = sourceEntry;
-        handleCacheItem(source, htmlEntry, SourceEntry.CONTENT);
-        handleCacheItem(source, htmlEntry, SourceEntry.LINE_INFO);
-        // These values are not currently being computed, so their state is
-        // not interesting.
-//        handleCacheItem(source, htmlEntry, HtmlEntry.ANGULAR_APPLICATION);
-//        handleCacheItem(source, htmlEntry, HtmlEntry.ANGULAR_COMPONENT);
-//        handleCacheItem(source, htmlEntry, HtmlEntry.ANGULAR_ENTRY);
-//        handleCacheItem(source, htmlEntry, HtmlEntry.ANGULAR_ERRORS);
-        handleCacheItem(source, htmlEntry, HtmlEntry.ELEMENT);
-        handleCacheItem(source, htmlEntry, HtmlEntry.PARSE_ERRORS);
-        handleCacheItem(source, htmlEntry, HtmlEntry.PARSED_UNIT);
-        // These values are not currently being computed, so their state is
-        // not interesting.
-//        handleCacheItem(source, htmlEntry, HtmlEntry.POLYMER_BUILD_ERRORS);
-//        handleCacheItem(source, htmlEntry, HtmlEntry.POLYMER_RESOLUTION_ERRORS);
-        handleCacheItem(source, htmlEntry, HtmlEntry.RESOLUTION_ERRORS);
-        handleCacheItem(source, htmlEntry, HtmlEntry.RESOLVED_UNIT);
-        // We are not currently recording any hints related to HTML.
-//        handleCacheItem(key, htmlEntry, HtmlEntry.HINTS);
       }
     }
   }
 
   /**
    * Record that we have accessed the AST structure associated with the given source. At the moment,
    * there is no differentiation between the parsed and resolved forms of the AST.
    *
    * @param source the source whose AST structure was accessed
    */
@@ skipping 462 matching lines @@
       }
     } else if (originalContents != null) {
       _incrementalAnalysisCache =
           IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
       _sourceChanged(source);
       changed = true;
     }
     return changed;
   }
 
+//  /**
+//   * Create a [BuildUnitElementTask] for the given [source].
+//   */
+//  AnalysisContextImpl_TaskData _createBuildUnitElementTask(Source source,
+//      DartEntry dartEntry, Source librarySource) {
+//    CompilationUnit unit = dartEntry.resolvableCompilationUnit;
+//    if (unit == null) {
+//      return _createParseDartTask(source, dartEntry);
+//    }
+//    return new AnalysisContextImpl_TaskData(
+//        new BuildUnitElementTask(this, source, librarySource, unit),
+//        false);
+//  }
+
   /**
    * Set the contents of the given source to the given contents and mark the source as having
    * changed. This has the effect of overriding the default contents of the source. If the contents
    * are `null` the override is removed so that the default contents will be returned.
    * [setContents] triggers a source changed event where as this method does not.
    *
    * @param source the source whose contents are being overridden
    * @param contents the new contents of the source
    */
   bool _contentsChanged(Source source, String contents) {
@@ skipping 17 matching lines @@
       }
     } else if (originalContents != null) {
       _incrementalAnalysisCache =
           IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
       _sourceChanged(source);
       changed = true;
     }
     return changed;
   }
 
-//  /**
-//   * Create a [BuildUnitElementTask] for the given [source].
-//   */
-//  AnalysisContextImpl_TaskData _createBuildUnitElementTask(Source source,
-//      DartEntry dartEntry, Source librarySource) {
-//    CompilationUnit unit = dartEntry.resolvableCompilationUnit;
-//    if (unit == null) {
-//      return _createParseDartTask(source, dartEntry);
-//    }
-//    return new AnalysisContextImpl_TaskData(
-//        new BuildUnitElementTask(this, source, librarySource, unit),
-//        false);
-//  }
-
   /**
    * Create a [GenerateDartErrorsTask] for the given source, marking the verification errors
    * as being in-process. The compilation unit and the library can be the same if the compilation
    * unit is the defining compilation unit of the library.
    *
    * @param unitSource the source for the compilation unit to be verified
    * @param unitEntry the entry for the compilation unit
    * @param librarySource the source for the library containing the compilation unit
    * @param libraryEntry the entry for the library
    * @return task data representing the created task
@@ skipping 880 matching lines @@
    */
   SourceEntry _getReadableSourceEntry(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       sourceEntry = _createSourceEntry(source, false);
     }
     return sourceEntry;
   }
 
   /**
-   * Return the cache entry associated with the given source, or `null` if there is no entry
-   * associated with the source.
-   *
-   * @param source the source for which a cache entry is being sought
-   * @return the source cache entry associated with the given source
-   */
-  SourceEntry _getReadableSourceEntryOrNull(Source source) =>
-      _cache.get(source);
-
-  /**
    * Return a resolved compilation unit corresponding to the given element in the given library, or
    * `null` if the information is not cached.
    *
    * @param element the element representing the compilation unit
    * @param librarySource the source representing the library containing the unit
    * @return the specified resolved compilation unit
    */
   TimestampedData<CompilationUnit>
       _getResolvedUnit(CompilationUnitElement element, Source librarySource) {
     SourceEntry sourceEntry = _cache.get(element.source);
@@ skipping 1042 matching lines @@
       dartEntry.recordContentError(
           new CaughtException(
               new AnalysisException("This source was marked as being deleted"),
               null));
     }
     _workManager.remove(source);
     _removeFromPriorityOrder(source);
   }
 
   /**
+   * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
+   *
+   * @param source the source that has been removed
+   */
+  void _sourceRemoved(Source source) {
+    SourceEntry sourceEntry = _cache.get(source);
+    if (sourceEntry is HtmlEntry) {
+      _invalidateAngularResolution(sourceEntry);
+    } else if (sourceEntry is DartEntry) {
+      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);
+      }
+    }
+    _cache.remove(source);
+    _workManager.remove(source);
+    _removeFromPriorityOrder(source);
+  }
+
+  /**
    * TODO(scheglov) A hackish, limited incremental resolution implementation.
    */
   bool _tryPoorMansIncrementalResolution(Source unitSource, String newCode) {
     DartEntry dartEntry = _cache.get(unitSource);
     if (dartEntry == null) {
       return false;
     }
     // prepare the (only) library
     List<Source> librarySources = getLibrariesContaining(unitSource);
     if (librarySources.length != 1) {
@@ skipping 17 matching lines @@
     notice.compilationUnit = oldUnit;
     // TODO(scheglov) apply updated errors
     {
       LineInfo lineInfo = getLineInfo(unitSource);
       notice.setErrors(dartEntry.allErrors, lineInfo);
     }
     return true;
   }
 
   /**
-   * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
-   *
-   * @param source the source that has been removed
-   */
-  void _sourceRemoved(Source source) {
-    SourceEntry sourceEntry = _cache.get(source);
-    if (sourceEntry is HtmlEntry) {
-      _invalidateAngularResolution(sourceEntry);
-    } else if (sourceEntry is DartEntry) {
-      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);
-      }
-    }
-    _cache.remove(source);
-    _workManager.remove(source);
-    _removeFromPriorityOrder(source);
-  }
-
-  /**
    * Check the cache for any invalid entries (entries whose modification time does not match the
    * modification time of the source associated with the entry). Invalid entries will be marked as
    * invalid so that the source will be re-analyzed.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @return `true` if at least one entry was invalid
    */
   bool _validateCacheConsistency() {
     int consistencyCheckStart = JavaSystem.nanoTime();
@@ skipping 3797 matching lines @@
    * 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
+  List<DataDescriptor> get descriptors {
+    List<DataDescriptor> result = super.descriptors;
+    result.addAll(
+        <DataDescriptor>[
+            DartEntry.SOURCE_KIND,
+            DartEntry.CONTAINING_LIBRARIES,
+            DartEntry.PARSE_ERRORS,
+            DartEntry.PARSED_UNIT,
+            DartEntry.SCAN_ERRORS,
+            DartEntry.SOURCE_KIND,
+            DartEntry.TOKEN_STREAM]);
+    SourceKind kind = getValue(DartEntry.SOURCE_KIND);
+    if (kind == SourceKind.LIBRARY) {
+      result.addAll(
+          <DataDescriptor>[
+              DartEntry.ELEMENT,
+              DartEntry.EXPORTED_LIBRARIES,
+              DartEntry.IMPORTED_LIBRARIES,
+              DartEntry.INCLUDED_PARTS,
+              DartEntry.IS_CLIENT,
+              DartEntry.IS_LAUNCHABLE,
+              DartEntry.PUBLIC_NAMESPACE]);
+    }
+    return result;
+  }
+
   /**
    * 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 (getState(PARSED_UNIT) == CacheState.VALID) {
       return true;
     }
     ResolutionState state = _resolutionState;
@@ skipping 36 matching lines @@
     while (state != null) {
       if (state._librarySource != null) {
         result.add(state._librarySource);
       }
       state = state._nextState;
     }
     return result;
   }
 
   /**
+   * Get a list of all the library-dependent descriptors for which values may
+   * be stored in this SourceEntry.
+   */
+  List<DataDescriptor> get libraryDescriptors {
+    return <DataDescriptor>[
+        DartEntry.ANGULAR_ERRORS,
+        DartEntry.BUILT_ELEMENT,
+        DartEntry.BUILT_UNIT,
+        DartEntry.RESOLUTION_ERRORS,
+        DartEntry.RESOLVED_UNIT,
+        DartEntry.VERIFICATION_ERRORS,
+        DartEntry.HINTS];
+  }
+
+  /**
    * 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 (getState(PARSED_UNIT) == CacheState.VALID) {
       CompilationUnit unit = getValue(PARSED_UNIT);
       setState(PARSED_UNIT, CacheState.FLUSHED);
       return unit;
     }
@@ skipping 1102 matching lines @@
     if (getState(PARSED_UNIT) == CacheState.VALID) {
       return getValue(PARSED_UNIT);
     }
     if (getState(RESOLVED_UNIT) == CacheState.VALID) {
       return getValue(RESOLVED_UNIT);
     }
     return null;
   }
 
   @override
+  List<DataDescriptor> get descriptors {
+    List<DataDescriptor> result = super.descriptors;
+    result.addAll(
+        [
+            HtmlEntry.ANGULAR_APPLICATION,
+            HtmlEntry.ANGULAR_COMPONENT,
+            HtmlEntry.ANGULAR_ENTRY,
+            HtmlEntry.ANGULAR_ERRORS,
+            HtmlEntry.ELEMENT,
+            HtmlEntry.PARSE_ERRORS,
+            HtmlEntry.PARSED_UNIT,
+            HtmlEntry.POLYMER_BUILD_ERRORS,
+            HtmlEntry.POLYMER_RESOLUTION_ERRORS,
+            HtmlEntry.RESOLUTION_ERRORS,
+            HtmlEntry.RESOLVED_UNIT,
+            HtmlEntry.HINTS]);
+    return result;
+  }
+
+  @override
   SourceKind get kind => SourceKind.HTML;
 
   /**
    * Flush any AST structures being maintained by this entry.
    */
   void flushAstStructures() {
     _flush(PARSED_UNIT);
     _flush(RESOLVED_UNIT);
     _flush(ANGULAR_ENTRY);
     _flush(ANGULAR_ERRORS);
@@ skipping 4182 matching lines @@
   int _flags = 0;
 
   /**
    * A table mapping data descriptors to the cached results for those
    * descriptors.
    */
   Map<DataDescriptor, CachedResult> resultMap =
       new HashMap<DataDescriptor, CachedResult>();
 
   /**
+   * Get a list of all the library-independent descriptors for which values may
+   * be stored in this SourceEntry.
+   */
+  List<DataDescriptor> get descriptors {
+    return <DataDescriptor>[SourceEntry.CONTENT, SourceEntry.LINE_INFO];
+  }
+
+  /**
    * 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.
    */
   bool get explicitlyAdded => _getFlag(_EXPLICITLY_ADDED_FLAG);
 
   /**
    * Set whether the source was explicitly added to the context to match the
    * [explicitlyAdded] flag.
    */
@@ skipping 685 matching lines @@
 
   @override
   Object visitPolymerTagDartElement(PolymerTagDartElement element) {
     if (element.name == PolymerHtmlUnitBuilder_this._elementName) {
       throw new PolymerHtmlUnitBuilder_FoundTagDartElementError(
           element as PolymerTagDartElementImpl);
     }
     return null;
   }
 }