Simplify constructors translation, improve code style.

pkg/analyzer_experimental/lib/src/generated/engine.dart

 // 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' show HasNextIterator;
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'instrumentation.dart';
 import 'error.dart';
 import 'source.dart';
 import 'scanner.dart' show Token, CharBufferScanner, StringScanner;
@@ skipping 586 matching lines @@
  * Instances of the class `AnalysisException` represent an exception that occurred during the
  * analysis of one or more sources.
  *
  * @coverage dart.engine
  */
 class AnalysisException extends JavaException {
 
   /**
    * Initialize a newly created exception.
    */
-  AnalysisException() : super() {
-    _jtd_constructor_126_impl();
-  }
-  _jtd_constructor_126_impl() {
-  }
+  AnalysisException() : super();
 
   /**
    * Initialize a newly created exception to have the given message.
    *
    * @param message the message associated with the exception
    */
-  AnalysisException.con1(String message) : super(message) {
-    _jtd_constructor_127_impl(message);
-  }
-  _jtd_constructor_127_impl(String message) {
-  }
+  AnalysisException.con1(String message) : super(message);
 
   /**
    * Initialize a newly created exception to have the given message and cause.
    *
    * @param message the message associated with the exception
    * @param cause the underlying exception that caused this exception
    */
-  AnalysisException.con2(String message, Exception cause) : super(message, cause) {
-    _jtd_constructor_128_impl(message, cause);
-  }
-  _jtd_constructor_128_impl(String message, Exception cause) {
-  }
+  AnalysisException.con2(String message, Exception cause) : super(message, cause);
 
   /**
    * Initialize a newly created exception to have the given cause.
    *
    * @param cause the underlying exception that caused this exception
    */
-  AnalysisException.con3(Exception cause) : super.withCause(cause) {
-    _jtd_constructor_129_impl(cause);
-  }
-  _jtd_constructor_129_impl(Exception cause) {
-  }
+  AnalysisException.con3(Exception cause) : super.withCause(cause);
 }
 /**
  * The interface `AnalysisOptions` defines the behavior of objects that provide access to a
  * set of analysis options used to control the behavior of an analysis context.
  */
 abstract class AnalysisOptions {
 
   /**
-   * Return `true` if analysis is to generate audit results (e.g. type inference based
+   * Return `true` if analysis is to generate hint results (e.g. type inference based
    * information and pub best practices).
    *
-   * @return `true` if analysis is to generate audit results
+   * @return `true` if analysis is to generate hint results
    */
-  bool get audit;
+  bool get hint;
 
   /**
    * Return `true` if analysis is to use strict mode. In strict mode, error reporting is based
    * exclusively on the static type information.
    *
    * @return `true` if analysis is to use strict mode
    */
   bool get strictMode;
 }
 /**
@@ skipping 138 matching lines @@
    */
   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");
@@ skipping 214 matching lines @@
   List<AnalysisError> get allErrors {
     List<AnalysisError> errors = new List<AnalysisError>();
     for (AnalysisError error in _parseErrors) {
       errors.add(error);
     }
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
       for (AnalysisError error in state._resolutionErrors) {
         errors.add(error);
       }
+      for (AnalysisError error in state._hints) {
+        errors.add(error);
+      }
       state = state._nextState;
     }
     ;
     if (errors.length == 0) {
       return AnalysisError.NO_ERRORS;
     }
     return new List.from(errors);
   }
   CompilationUnit get anyParsedCompilationUnit {
     if (identical(_parsedUnitState, CacheState.VALID)) {
@@ skipping 39 matching lines @@
     }
   }
   CacheState getState2(DataDescriptor<Object> descriptor, Source librarySource2) {
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
       if (librarySource2 == state._librarySource) {
         if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
           return _resolutionState._resolutionErrorsState;
         } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
           return _resolutionState._resolvedUnitState;
+        } else if (identical(descriptor, DartEntry.HINTS)) {
+          return _resolutionState._hintsState;
         } else {
           throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
         }
       }
       state = state._nextState;
     }
     ;
     return CacheState.INVALID;
   }
   Object getValue(DataDescriptor descriptor) {
@@ skipping 21 matching lines @@
     return super.getValue(descriptor);
   }
   Object getValue2(DataDescriptor descriptor, Source librarySource2) {
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
       if (librarySource2 == state._librarySource) {
         if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
           return state._resolutionErrors as Object;
         } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
           return state._resolvedUnit as Object;
+        } else if (identical(descriptor, DartEntry.HINTS)) {
+          return state._hints as Object;
         } else {
           throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
         }
       }
       state = state._nextState;
     }
     ;
-    if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
+    if (identical(descriptor, DartEntry.RESOLUTION_ERRORS) || identical(descriptor, DartEntry.HINTS)) {
       return AnalysisError.NO_ERRORS as Object;
     } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
       return null;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
   DartEntryImpl get writableCopy {
     DartEntryImpl copy = new DartEntryImpl();
     copy.copyFrom(this);
@@ skipping 40 matching lines @@
    * as being in error.
    */
   void recordParseError() {
     setState(SourceEntry.LINE_INFO, CacheState.ERROR);
     _sourceKind = SourceKind.UNKNOWN;
     _sourceKindState = CacheState.ERROR;
     _parseErrors = AnalysisError.NO_ERRORS;
     _parseErrorsState = CacheState.ERROR;
     _parsedUnit = null;
     _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();
   }
 
   /**
    * Record that the parse-related information for the associated source is about to be computed by
    * the current thread.
    */
   void recordParseInProcess() {
     if (getState(SourceEntry.LINE_INFO) != CacheState.VALID) {
       setState(SourceEntry.LINE_INFO, CacheState.IN_PROCESS);
     }
     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 error occurred while attempting to scan or parse the entry represented by this
    * entry. This will set the state of all resolution-based information as being in error, but will
    * not change the state of any parse results.
    */
   void recordResolutionError() {
     _element = null;
     _elementState = CacheState.ERROR;
-    _includedParts = Source.EMPTY_ARRAY;
-    _includedPartsState = CacheState.ERROR;
-    _exportedLibraries = Source.EMPTY_ARRAY;
-    _exportedLibrariesState = CacheState.ERROR;
-    _importedLibraries = Source.EMPTY_ARRAY;
-    _importedLibrariesState = CacheState.ERROR;
     _bitmask = 0;
     _clientServerState = CacheState.ERROR;
     _launchableState = CacheState.ERROR;
     _publicNamespace = null;
     _publicNamespaceState = CacheState.ERROR;
     _resolutionState.recordResolutionError();
   }
 
   /**
    * Remove any resolution information associated with this compilation unit being part of the given
@@ skipping 91 matching lines @@
    * @param cacheState the new state of the data represented by the given descriptor
    */
   void setState2(DataDescriptor<Object> descriptor, Source librarySource, CacheState cacheState) {
     DartEntryImpl_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.HINTS)) {
+      state._hints = updatedValue(cacheState, state._hints, AnalysisError.NO_ERRORS);
+      state._hintsState = cacheState;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
   void setValue(DataDescriptor descriptor, Object value) {
     if (identical(descriptor, DartEntry.ELEMENT)) {
       _element = value as LibraryElement;
       _elementState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.EXPORTED_LIBRARIES)) {
       _exportedLibraries = value == null ? Source.EMPTY_ARRAY : (value as List<Source>);
@@ skipping 45 matching lines @@
    * @param value the new value of the data represented by the given descriptor and library
    */
   void setValue2(DataDescriptor descriptor, Source librarySource, Object value) {
     DartEntryImpl_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.HINTS)) {
+      state._hints = value == null ? AnalysisError.NO_ERRORS : (value as List<AnalysisError>);
+      state._hintsState = CacheState.VALID;
     }
   }
   void copyFrom(SourceEntryImpl entry) {
     super.copyFrom(entry);
     DartEntryImpl other = entry as DartEntryImpl;
     _sourceKindState = other._sourceKindState;
     _sourceKind = other._sourceKind;
     _parsedUnitState = other._parsedUnitState;
     _parsedUnit = other._parsedUnit;
     _parseErrorsState = other._parseErrorsState;
@@ skipping 84 matching lines @@
    * currently cached.
    */
   CompilationUnit _resolvedUnit;
 
   /**
    * The state of the cached resolution errors.
    */
   CacheState _resolutionErrorsState = CacheState.INVALID;
 
   /**
-   * The errors produced while resolving the compilation unit, or `null` if the errors are
+   * 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 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;
+
+  /**
    * Set this state to be exactly like the given state, recursively copying the next state as
    * necessary.
    *
    * @param other the state to be copied
    */
   void copyFrom(DartEntryImpl_ResolutionState other) {
     _librarySource = other._librarySource;
     _resolvedUnitState = other._resolvedUnitState;
     _resolvedUnit = other._resolvedUnit;
     _resolutionErrorsState = other._resolutionErrorsState;
     _resolutionErrors = other._resolutionErrors;
+    _hintsState = other._hintsState;
+    _hints = other._hints;
     if (other._nextState != null) {
       _nextState = new DartEntryImpl_ResolutionState();
       _nextState.copyFrom(other._nextState);
     }
   }
 
   /**
    * Invalidate all of the resolution information associated with the compilation unit.
    */
   void invalidateAllResolutionInformation() {
     _nextState = null;
     _librarySource = null;
     _resolvedUnitState = CacheState.INVALID;
     _resolvedUnit = null;
     _resolutionErrorsState = CacheState.INVALID;
     _resolutionErrors = AnalysisError.NO_ERRORS;
+    _hintsState = CacheState.INVALID;
+    _hints = AnalysisError.NO_ERRORS;
   }
 
   /**
    * Record that an error occurred while attempting to scan or parse the entry represented by this
    * entry. This will set the state of all resolution-based information as being in error, but
    * will not change the state of any parse results.
    */
   void recordResolutionError() {
     _nextState = null;
     _librarySource = null;
     _resolvedUnitState = CacheState.ERROR;
     _resolvedUnit = null;
     _resolutionErrorsState = CacheState.ERROR;
     _resolutionErrors = AnalysisError.NO_ERRORS;
+    _hintsState = CacheState.ERROR;
+    _hints = AnalysisError.NO_ERRORS;
   }
 }
 /**
  * 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.
@@ skipping 32 matching lines @@
    * 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 resolved AST structure.
-   */
-  static final DataDescriptor<HtmlUnit> RESOLVED_UNIT = new DataDescriptor<HtmlUnit>("HtmlEntry.RESOLVED_UNIT");
-
-  /**
    * 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;
   HtmlEntryImpl get writableCopy;
 }
 /**
  * Instances of the class `HtmlEntryImpl` implement an [HtmlEntry].
  *
@@ skipping 16 matching lines @@
    */
   CacheState _resolutionErrorsState = CacheState.INVALID;
 
   /**
    * The errors produced while resolving the compilation unit, or `null` if the errors are not
    * currently cached.
    */
   List<AnalysisError> _resolutionErrors = AnalysisError.NO_ERRORS;
 
   /**
-   * The state of the cached parsed and resolved HTML unit.
-   */
-  CacheState _resolvedUnitState = CacheState.INVALID;
-
-  /**
-   * The resolved HTML unit, or `null` if the resolved HTML unit is not currently cached.
-   */
-  HtmlUnit _resolvedUnit;
-
-  /**
    * The state of the cached list of referenced libraries.
    */
   CacheState _referencedLibrariesState = CacheState.INVALID;
 
   /**
    * The list of libraries referenced in the HTML, or `null` if the list is not currently
    * cached. Note that this list does not include libraries defined directly within the HTML file.
    */
   List<Source> _referencedLibraries = Source.EMPTY_ARRAY;
 
@@ skipping 19 matching lines @@
   SourceKind get kind => SourceKind.HTML;
   CacheState getState(DataDescriptor<Object> descriptor) {
     if (identical(descriptor, HtmlEntry.ELEMENT)) {
       return _elementState;
     } else if (identical(descriptor, HtmlEntry.PARSED_UNIT)) {
       return _parsedUnitState;
     } else if (identical(descriptor, HtmlEntry.REFERENCED_LIBRARIES)) {
       return _referencedLibrariesState;
     } else if (identical(descriptor, HtmlEntry.RESOLUTION_ERRORS)) {
       return _resolutionErrorsState;
-    } else if (identical(descriptor, HtmlEntry.RESOLVED_UNIT)) {
-      return _resolvedUnitState;
     }
     return super.getState(descriptor);
   }
   Object getValue(DataDescriptor descriptor) {
     if (identical(descriptor, HtmlEntry.ELEMENT)) {
       return _element as Object;
     } else if (identical(descriptor, HtmlEntry.PARSED_UNIT)) {
       return _parsedUnit as Object;
     } else if (identical(descriptor, HtmlEntry.REFERENCED_LIBRARIES)) {
       return _referencedLibraries as Object;
     } else if (identical(descriptor, HtmlEntry.RESOLUTION_ERRORS)) {
       return _resolutionErrors as Object;
-    } else if (identical(descriptor, HtmlEntry.RESOLVED_UNIT)) {
-      return _resolvedUnit as Object;
     }
     return super.getValue(descriptor);
   }
   HtmlEntryImpl get writableCopy {
     HtmlEntryImpl copy = new HtmlEntryImpl();
     copy.copyFrom(this);
     return copy;
   }
+
+  /**
+   * Invalidate all of the resolution information associated with the compilation unit.
+   */
+  void invalidateAllResolutionInformation() {
+    _element = null;
+    _elementState = CacheState.INVALID;
+    _resolutionErrors = AnalysisError.NO_ERRORS;
+    _resolutionErrorsState = CacheState.INVALID;
+  }
   void setState(DataDescriptor<Object> descriptor, CacheState state) {
     if (identical(descriptor, HtmlEntry.ELEMENT)) {
       _element = updatedValue(state, _element, null);
       _elementState = state;
     } else if (identical(descriptor, HtmlEntry.PARSED_UNIT)) {
       _parsedUnit = updatedValue(state, _parsedUnit, null);
       _parsedUnitState = state;
     } else if (identical(descriptor, HtmlEntry.REFERENCED_LIBRARIES)) {
       _referencedLibraries = updatedValue(state, _referencedLibraries, Source.EMPTY_ARRAY);
       _referencedLibrariesState = state;
     } else if (identical(descriptor, HtmlEntry.RESOLUTION_ERRORS)) {
       _resolutionErrors = updatedValue(state, _resolutionErrors, AnalysisError.NO_ERRORS);
       _resolutionErrorsState = state;
-    } else if (identical(descriptor, HtmlEntry.RESOLVED_UNIT)) {
-      _resolvedUnit = updatedValue(state, _resolvedUnit, null);
-      _resolvedUnitState = state;
     } else {
       super.setState(descriptor, state);
     }
   }
   void setValue(DataDescriptor descriptor, Object value) {
     if (identical(descriptor, HtmlEntry.ELEMENT)) {
       _element = value as HtmlElement;
       _elementState = CacheState.VALID;
     } else if (identical(descriptor, HtmlEntry.PARSED_UNIT)) {
       _parsedUnit = value as HtmlUnit;
       _parsedUnitState = CacheState.VALID;
     } else if (identical(descriptor, HtmlEntry.REFERENCED_LIBRARIES)) {
       _referencedLibraries = value == null ? Source.EMPTY_ARRAY : (value as List<Source>);
       _referencedLibrariesState = CacheState.VALID;
     } else if (identical(descriptor, HtmlEntry.RESOLUTION_ERRORS)) {
       _resolutionErrors = value as List<AnalysisError>;
       _resolutionErrorsState = CacheState.VALID;
-    } else if (identical(descriptor, HtmlEntry.RESOLVED_UNIT)) {
-      _resolvedUnit = value as HtmlUnit;
-      _resolvedUnitState = CacheState.VALID;
     } else {
       super.setValue(descriptor, value);
     }
   }
   void copyFrom(SourceEntryImpl entry) {
     super.copyFrom(entry);
     HtmlEntryImpl other = entry as HtmlEntryImpl;
     _parsedUnitState = other._parsedUnitState;
     _parsedUnit = other._parsedUnit;
     _referencedLibrariesState = other._referencedLibrariesState;
     _referencedLibraries = other._referencedLibraries;
     _resolutionErrors = other._resolutionErrors;
     _resolutionErrorsState = other._resolutionErrorsState;
-    _resolvedUnitState = other._resolvedUnitState;
-    _resolvedUnit = other._resolvedUnit;
     _elementState = other._elementState;
     _element = other._element;
   }
 }
 /**
  * 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.
@@ skipping 191 matching lines @@
   Map<Source, ChangeNoticeImpl> _pendingNotices = new Map<Source, ChangeNoticeImpl>();
 
   /**
    * A list containing the most recently accessed sources with the most recently used at the end of
    * the list. When more sources are added than the maximum allowed then the least recently used
    * source will be removed and will have it's cached AST structure flushed.
    */
   List<Source> _recentlyUsed = new List<Source>();
 
   /**
+   * The number of times that the flushing of information from the cache has been disabled without
+   * being re-enabled.
+   */
+  int _cacheRemovalCount = 0;
+
+  /**
    * The object used to synchronize access to all of the caches.
    */
   Object _cacheLock = new Object();
 
   /**
    * The maximum number of sources for which data should be kept in the cache.
    */
   static int _MAX_CACHE_SIZE = 64;
 
   /**
    * The name of the 'src' attribute in a HTML tag.
    */
   static String _ATTRIBUTE_SRC = "src";
 
   /**
    * The name of the 'type' attribute in a HTML tag.
    */
   static String _ATTRIBUTE_TYPE = "type";
 
   /**
    * The name of the 'script' tag in an HTML file.
    */
   static String _TAG_SCRIPT = "script";
 
   /**
    * The value of the 'type' attribute of a 'script' tag that indicates that the script is written
    * in Dart.
    */
   static String _TYPE_DART = "application/dart";
-
-  /**
-   * The number of times that the flushing of information from the cache has been disabled without
-   * being re-enabled.
-   */
-  int _cacheRemovalCount = 0;
   void addSourceInfo(Source source, SourceEntry info) {
     _sourceMap[source] = info;
   }
   void applyChanges(ChangeSet changeSet) {
     if (changeSet.isEmpty) {
       return;
     }
     {
       List<Source> removedSources = new List<Source>.from(changeSet.removed);
       for (SourceContainer container in changeSet.removedContainers) {
@@ skipping 105 matching lines @@
     if (!AnalysisEngine.isHtmlFileName(source.shortName)) {
       return null;
     }
     {
       HtmlEntry htmlEntry = getHtmlEntry(source);
       if (htmlEntry == null) {
         return null;
       }
       HtmlElement element = htmlEntry.getValue(HtmlEntry.ELEMENT);
       if (element == null) {
-        HtmlUnit unit = htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT);
+        HtmlUnit unit = htmlEntry.getValue(HtmlEntry.PARSED_UNIT);
         if (unit == null) {
-          unit = htmlEntry.getValue(HtmlEntry.PARSED_UNIT);
-          if (unit == null) {
-            unit = parseHtmlUnit(source);
-          }
+          unit = parseHtmlUnit(source);
         }
         HtmlUnitBuilder builder = new HtmlUnitBuilder(this);
         element = builder.buildHtmlElement2(source, unit);
         List<AnalysisError> resolutionErrors = builder.errorListener.getErrors2(source);
         HtmlEntryImpl htmlCopy = getHtmlEntry(source).writableCopy;
-        htmlCopy.setValue(HtmlEntry.RESOLVED_UNIT, unit);
         htmlCopy.setValue(HtmlEntry.RESOLUTION_ERRORS, resolutionErrors);
         htmlCopy.setValue(HtmlEntry.ELEMENT, element);
         _sourceMap[source] = htmlCopy;
         getNotice(source).setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
       }
       return element;
     }
   }
   List<Source> computeImportedLibraries(Source source) {
     {
@@ skipping 99 matching lines @@
         if (container.contains(source)) {
           sourcesToRemove.add(source);
           newContext.addSourceInfo(source, entry.getValue().writableCopy);
         }
       }
     }
     return newContext;
   }
   AnalysisOptions get analysisOptions => _options;
   Element getElement(ElementLocation location) {
-    List<String> components = ((location as ElementLocationImpl)).components;
-    ElementImpl element;
-    {
-      Source librarySource = _sourceFactory.fromEncoding(components[0]);
-      try {
-        element = computeLibraryElement(librarySource) as ElementImpl;
-      } on AnalysisException catch (exception) {
-        return null;
+    try {
+      List<String> components = ((location as ElementLocationImpl)).components;
+      Source librarySource = computeSourceFromEncoding(components[0]);
+      ElementImpl element = computeLibraryElement(librarySource) as ElementImpl;
+      for (int i = 1; i < components.length; i++) {
+        if (element == null) {
+          return null;
+        }
+        element = element.getChild(components[i]);
       }
+      return element;
+    } on AnalysisException catch (exception) {
+      return null;
     }
-    for (int i = 1; i < components.length; i++) {
-      if (element == null) {
-        return null;
-      }
-      element = element.getChild(components[i]);
-    }
-    return element;
   }
   AnalysisErrorInfo getErrors(Source source) {
     SourceEntry sourceEntry = getReadableSourceEntry(source);
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry as DartEntry;
       return new AnalysisErrorInfoImpl(dartEntry.allErrors, dartEntry.getValue(SourceEntry.LINE_INFO));
     } else if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry as HtmlEntry;
       return new AnalysisErrorInfoImpl(htmlEntry.allErrors, htmlEntry.getValue(SourceEntry.LINE_INFO));
     }
@@ skipping 121 matching lines @@
     Source source = library.definingCompilationUnit.source;
     {
       DartEntry dartEntry = getDartEntry(source);
       if (dartEntry == null) {
         return null;
       }
       Namespace namespace = dartEntry.getValue(DartEntry.PUBLIC_NAMESPACE);
       if (namespace == null) {
         NamespaceBuilder builder = new NamespaceBuilder();
         namespace = builder.createPublicNamespace(library);
-        DartEntryImpl dartCopy = dartEntry.writableCopy;
+        DartEntryImpl dartCopy = getDartEntry(source).writableCopy;
         dartCopy.setValue(DartEntry.PUBLIC_NAMESPACE, namespace);
         _sourceMap[source] = dartCopy;
       }
       return namespace;
     }
   }
   Namespace getPublicNamespace2(Source source) {
     {
       DartEntry dartEntry = getDartEntry(source);
       if (dartEntry == null) {
         return null;
       }
       Namespace namespace = dartEntry.getValue(DartEntry.PUBLIC_NAMESPACE);
       if (namespace == null) {
         LibraryElement library = computeLibraryElement(source);
         if (library == null) {
           return null;
         }
         NamespaceBuilder builder = new NamespaceBuilder();
         namespace = builder.createPublicNamespace(library);
-        DartEntryImpl dartCopy = dartEntry.writableCopy;
+        DartEntryImpl dartCopy = getDartEntry(source).writableCopy;
         dartCopy.setValue(DartEntry.PUBLIC_NAMESPACE, namespace);
         _sourceMap[source] = dartCopy;
       }
       return namespace;
     }
   }
   CompilationUnit getResolvedCompilationUnit(Source unitSource, LibraryElement library) {
     if (library == null) {
       return null;
     }
@@ skipping 51 matching lines @@
       return unit;
     }
   }
   HtmlUnit parseHtmlUnit(Source source) {
     {
       accessed(source);
       HtmlEntry htmlEntry = getHtmlEntry(source);
       if (htmlEntry == null) {
         return null;
       }
-      HtmlUnit unit = htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT);
+      HtmlUnit unit = htmlEntry.getValue(HtmlEntry.PARSED_UNIT);
       if (unit == null) {
-        unit = htmlEntry.getValue(HtmlEntry.PARSED_UNIT);
-        if (unit == null) {
-          try {
-            HtmlParseResult result = new HtmlParser(source).parse(scanHtml(source));
-            unit = result.htmlUnit;
-            HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-            htmlCopy.setValue(SourceEntry.LINE_INFO, new LineInfo(result.lineStarts));
-            htmlCopy.setValue(HtmlEntry.PARSED_UNIT, unit);
-            htmlCopy.setValue(HtmlEntry.REFERENCED_LIBRARIES, getLibrarySources2(source, unit));
-            _sourceMap[source] = htmlCopy;
-          } on AnalysisException catch (exception) {
-            HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-            htmlCopy.setState(SourceEntry.LINE_INFO, CacheState.ERROR);
-            htmlCopy.setState(HtmlEntry.PARSED_UNIT, CacheState.ERROR);
-            htmlCopy.setState(HtmlEntry.REFERENCED_LIBRARIES, CacheState.ERROR);
-            _sourceMap[source] = htmlCopy;
-            throw exception;
-          }
+        try {
+          HtmlParseResult result = new HtmlParser(source).parse(scanHtml(source));
+          unit = result.htmlUnit;
+          HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
+          htmlCopy.setValue(SourceEntry.LINE_INFO, new LineInfo(result.lineStarts));
+          htmlCopy.setValue(HtmlEntry.PARSED_UNIT, unit);
+          htmlCopy.setValue(HtmlEntry.REFERENCED_LIBRARIES, getLibrarySources2(source, unit));
+          _sourceMap[source] = htmlCopy;
+        } on AnalysisException catch (exception) {
+          HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
+          htmlCopy.setState(SourceEntry.LINE_INFO, CacheState.ERROR);
+          htmlCopy.setState(HtmlEntry.PARSED_UNIT, CacheState.ERROR);
+          htmlCopy.setState(HtmlEntry.REFERENCED_LIBRARIES, CacheState.ERROR);
+          _sourceMap[source] = htmlCopy;
+          throw exception;
         }
       }
       return unit;
     }
   }
   List<ChangeNotice> performAnalysisTask() {
     {
       if (!performSingleAnalysisTask() && _pendingNotices.isEmpty) {
         return null;
       }
       if (_pendingNotices.isEmpty) {
         return ChangeNoticeImpl.EMPTY_ARRAY;
       }
       List<ChangeNotice> notices = new List.from(_pendingNotices.values);
       _pendingNotices.clear();
       return notices;
     }
   }
   void recordLibraryElements(Map<Source, LibraryElement> elementMap) {
-    Source htmlSource = _sourceFactory.forUri(DartSdk.DART_HTML);
     {
+      Source htmlSource = _sourceFactory.forUri(DartSdk.DART_HTML);
       for (MapEntry<Source, LibraryElement> entry in getMapEntrySet(elementMap)) {
         Source librarySource = entry.getKey();
         LibraryElement library = entry.getValue();
         DartEntry dartEntry = getDartEntry(librarySource);
         if (dartEntry != null) {
           DartEntryImpl dartCopy = dartEntry.writableCopy;
           recordElementData(dartCopy, library, htmlSource);
           _sourceMap[librarySource] = dartCopy;
         }
       }
@@ skipping 41 matching lines @@
             _sourceMap[unitSource] = dartCopy;
             unit = unitAST;
           }
         } finally {
           enableCacheRemoval();
         }
       }
       return unit;
     }
   }
-  HtmlUnit resolveHtmlUnit(Source unitSource) {
-    {
-      accessed(unitSource);
-      HtmlEntry htmlEntry = getHtmlEntry(unitSource);
-      if (htmlEntry == null) {
-        return null;
-      }
-      HtmlUnit unit = htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT);
-      if (unit == null) {
-        disableCacheRemoval();
-        try {
-          computeHtmlElement(unitSource);
-          unit = htmlEntry.getValue(HtmlEntry.RESOLVED_UNIT);
-          if (unit == null) {
-            unit = parseHtmlUnit(unitSource);
-          }
-        } on AnalysisException catch (exception) {
-          HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-          htmlCopy.setState(HtmlEntry.RESOLVED_UNIT, CacheState.ERROR);
-          _sourceMap[unitSource] = htmlCopy;
-          throw exception;
-        } finally {
-          enableCacheRemoval();
-        }
-      }
-      return unit;
-    }
-  }
+  HtmlUnit resolveHtmlUnit(Source source) => parseHtmlUnit(source);
   void set analysisOptions(AnalysisOptions options2) {
     {
       this._options = options2;
       invalidateAllResults();
     }
   }
   void set analysisPriorityOrder(List<Source> sources) {
     {
       if (sources == null || sources.isEmpty) {
         _priorityOrder = Source.EMPTY_ARRAY;
       } else {
         _priorityOrder = new List.from(sources);
       }
     }
   }
   void setContents(Source source, String contents) {
     {
       _sourceFactory.setContents(source, contents);
       sourceChanged(source);
     }
   }
   void set sourceFactory(SourceFactory factory) {
-    if (identical(_sourceFactory, factory)) {
-      return;
-    } else if (factory.context != null) {
-      throw new IllegalStateException("Source factories cannot be shared between contexts");
-    }
     {
+      if (identical(_sourceFactory, factory)) {
+        return;
+      } else if (factory.context != null) {
+        throw new IllegalStateException("Source factories cannot be shared between contexts");
+      }
       if (_sourceFactory != null) {
         _sourceFactory.context = null;
       }
       factory.context = this;
       _sourceFactory = factory;
       invalidateAllResults();
     }
   }
   Iterable<Source> sourcesToResolve(List<Source> changedSources) {
     List<Source> librarySources = new List<Source>();
@@ skipping 19 matching lines @@
         if (sourceEntry is DartEntry) {
           DartEntry dartEntry = sourceEntry as DartEntry;
           CacheState parsedUnitState = dartEntry.getState(DartEntry.PARSED_UNIT);
           CacheState elementState = dartEntry.getState(DartEntry.ELEMENT);
           if (identical(parsedUnitState, CacheState.INVALID) || identical(elementState, CacheState.INVALID)) {
             sources.add(entry.getKey());
           }
         } else if (sourceEntry is HtmlEntry) {
           HtmlEntry htmlEntry = sourceEntry as HtmlEntry;
           CacheState parsedUnitState = htmlEntry.getState(HtmlEntry.PARSED_UNIT);
-          CacheState resolvedUnitState = htmlEntry.getState(HtmlEntry.RESOLVED_UNIT);
-          if (identical(parsedUnitState, CacheState.INVALID) || identical(resolvedUnitState, CacheState.INVALID)) {
+          CacheState elementState = htmlEntry.getState(HtmlEntry.ELEMENT);
+          if (identical(parsedUnitState, CacheState.INVALID) || identical(elementState, CacheState.INVALID)) {
             sources.add(entry.getKey());
           }
         }
       }
     }
     return sources;
   }
 
   /**
    * Record that the given source was just accessed for some unspecified purpose.
    *
    * Note: This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source that was accessed
    */
   void accessed(Source source) {
-    if (_recentlyUsed.contains(source)) {
-      _recentlyUsed.remove(source);
+    if (_recentlyUsed.remove(source)) {
       _recentlyUsed.add(source);
       return;
     }
     if (_cacheRemovalCount == 0 && _recentlyUsed.length >= _MAX_CACHE_SIZE) {
-      Source removedSource = _recentlyUsed.removeAt(0);
-      SourceEntry sourceEntry = _sourceMap[removedSource];
-      if (sourceEntry is HtmlEntry) {
-        HtmlEntryImpl htmlCopy = ((sourceEntry as HtmlEntry)).writableCopy;
-        htmlCopy.setState(HtmlEntry.PARSED_UNIT, CacheState.FLUSHED);
-        htmlCopy.setState(HtmlEntry.RESOLVED_UNIT, CacheState.FLUSHED);
-        _sourceMap[removedSource] = htmlCopy;
-      } else if (sourceEntry is DartEntry) {
-        DartEntryImpl dartCopy = ((sourceEntry as DartEntry)).writableCopy;
-        dartCopy.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED);
-        for (Source librarySource in getLibrariesContaining(source)) {
-          dartCopy.setState2(DartEntry.RESOLVED_UNIT, librarySource, CacheState.FLUSHED);
-        }
-        _sourceMap[removedSource] = dartCopy;
-      }
+      flushAstFromCache();
     }
     _recentlyUsed.add(source);
   }
 
   /**
    * Add all of the sources contained in the given source container to the given list of sources.
    *
    * Note: This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param sources the list to which sources are to be added
    * @param container the source container containing the sources to be added to the list
    */
   void addSourcesInContainer(List<Source> sources, SourceContainer container) {
     for (Source source in _sourceMap.keys.toSet()) {
       if (container.contains(source)) {
         sources.add(source);
       }
     }
   }
 
   /**
+   * Given the encoded form of a source, use the source factory to reconstitute the original source.
+   *
+   * @param encoding the encoded form of a source
+   * @return the source represented by the encoding
+   */
+  Source computeSourceFromEncoding(String encoding) {
+    {
+      return _sourceFactory.fromEncoding(encoding);
+    }
+  }
+
+  /**
    * Return `true` if the given array of sources contains the given source.
    *
    * @param sources the sources being searched
    * @param targetSource the source being searched for
    * @return `true` if the given source is in the array
    */
   bool contains(List<Source> sources, Source targetSource) {
     for (Source source in sources) {
       if (source == targetSource) {
         return true;
@@ skipping 21 matching lines @@
   /**
    * 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
    * @return the source information object that was created
    */
   SourceEntry createSourceEntry(Source source) {
     String name = source.shortName;
     if (AnalysisEngine.isHtmlFileName(name)) {
-      HtmlEntry htmlEntry = new HtmlEntryImpl();
+      HtmlEntryImpl htmlEntry = new HtmlEntryImpl();
+      htmlEntry.modificationTime = source.modificationStamp;
       _sourceMap[source] = htmlEntry;
       return htmlEntry;
     } else {
-      DartEntry dartEntry = new DartEntryImpl();
+      DartEntryImpl dartEntry = new DartEntryImpl();
+      dartEntry.modificationTime = source.modificationStamp;
       _sourceMap[source] = dartEntry;
       return dartEntry;
     }
   }
 
   /**
    * Disable flushing information from the cache until [enableCacheRemoval] has been
    * called.
    */
   void disableCacheRemoval() {
     _cacheRemovalCount++;
   }
 
   /**
    * Re-enable flushing information from the cache.
    */
   void enableCacheRemoval() {
     if (_cacheRemovalCount > 0) {
       _cacheRemovalCount--;
     }
     if (_cacheRemovalCount == 0) {
       while (_recentlyUsed.length >= _MAX_CACHE_SIZE) {
-        Source removedSource = _recentlyUsed.removeAt(0);
-        SourceEntry sourceEntry = _sourceMap[removedSource];
-        if (sourceEntry is HtmlEntry) {
-          HtmlEntryImpl htmlCopy = ((sourceEntry as HtmlEntry)).writableCopy;
-          htmlCopy.setState(HtmlEntry.PARSED_UNIT, CacheState.FLUSHED);
-          htmlCopy.setState(HtmlEntry.RESOLVED_UNIT, CacheState.FLUSHED);
-          _sourceMap[removedSource] = htmlCopy;
-        } else if (sourceEntry is DartEntry) {
-          DartEntryImpl dartCopy = ((sourceEntry as DartEntry)).writableCopy;
-          dartCopy.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED);
-          for (Source librarySource in getLibrariesContaining(removedSource)) {
-            dartCopy.setState2(DartEntry.RESOLVED_UNIT, librarySource, CacheState.FLUSHED);
-          }
-          _sourceMap[removedSource] = dartCopy;
-        }
+        flushAstFromCache();
       }
     }
   }
 
   /**
    * Search the compilation units that are part of the given library and return the element
    * representing the compilation unit with the given source. Return `null` if there is no
    * such compilation unit.
    *
    * @param libraryElement the element representing the library being searched through
    * @param unitSource the source for the compilation unit whose element is to be returned
    * @return the element representing the compilation unit
    */
   CompilationUnitElement find(LibraryElement libraryElement, Source unitSource) {
     CompilationUnitElement element = libraryElement.definingCompilationUnit;
     if (element.source == unitSource) {
       return element;
     }
     for (CompilationUnitElement partElement in libraryElement.parts) {
       if (partElement.source == unitSource) {
         return partElement;
       }
     }
     return null;
   }
 
   /**
+   * Flush one AST structure from the cache.
+   *
+   * Note: This method must only be invoked while we are synchronized on [cacheLock].
+   */
+  void flushAstFromCache() {
+    Source removedSource = _recentlyUsed.removeAt(0);
+    SourceEntry sourceEntry = _sourceMap[removedSource];
+    if (sourceEntry is HtmlEntry) {
+      HtmlEntryImpl htmlCopy = ((sourceEntry as HtmlEntry)).writableCopy;
+      htmlCopy.setState(HtmlEntry.PARSED_UNIT, CacheState.FLUSHED);
+      _sourceMap[removedSource] = htmlCopy;
+    } else if (sourceEntry is DartEntry) {
+      DartEntryImpl dartCopy = ((sourceEntry as DartEntry)).writableCopy;
+      dartCopy.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED);
+      for (Source librarySource in getLibrariesContaining(removedSource)) {
+        dartCopy.setState2(DartEntry.RESOLVED_UNIT, librarySource, CacheState.FLUSHED);
+      }
+      _sourceMap[removedSource] = dartCopy;
+    }
+  }
+
+  /**
    * Return the compilation unit information associated with the given source, or `null` if
    * the source is not known to this context. This method should be used to access the compilation
    * unit information rather than accessing the compilation unit map directly because sources in the
    * SDK are implicitly part of every analysis context and are therefore only added to the map when
    * first accessed.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source for which information is being sought
    * @return the compilation unit information associated with the given source
@@ skipping 59 matching lines @@
   ChangeNoticeImpl getNotice(Source source) {
     ChangeNoticeImpl notice = _pendingNotices[source];
     if (notice == null) {
       notice = new ChangeNoticeImpl(source);
       _pendingNotices[source] = notice;
     }
     return notice;
   }
 
   /**
+   * Return the cache entry associated with the given source, or `null` if the source is not a
+   * Dart file.
+   *
+   * @param source the source for which a cache entry is being sought
+   * @return the source cache entry associated with the given source
+   */
+  DartEntry getReadableDartEntry(Source source) {
+    {
+      SourceEntry sourceEntry = _sourceMap[source];
+      if (sourceEntry == null) {
+        sourceEntry = createSourceEntry(source);
+      }
+      if (sourceEntry is DartEntry) {
+        accessed(source);
+        return sourceEntry as DartEntry;
+      }
+      return null;
+    }
+  }
+
+  /**
+   * Return the cache entry associated with the given source, or `null` if the source is not
+   * an HTML file.
+   *
+   * @param source the source for which a cache entry is being sought
+   * @return the source cache entry associated with the given source
+   */
+  HtmlEntry getReadableHtmlEntry(Source source) {
+    {
+      SourceEntry sourceEntry = _sourceMap[source];
+      if (sourceEntry == null) {
+        sourceEntry = createSourceEntry(source);
+      }
+      if (sourceEntry is HtmlEntry) {
+        accessed(source);
+        return sourceEntry as HtmlEntry;
+      }
+      return null;
+    }
+  }
+
+  /**
    * 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 getReadableSourceEntry(Source source) {
     {
-      return _sourceMap[source];
+      SourceEntry sourceEntry = _sourceMap[source];
+      if (sourceEntry == null) {
+        sourceEntry = createSourceEntry(source);
+      }
+      if (sourceEntry != null) {
+        accessed(source);
+      }
+      return sourceEntry;
     }
   }
 
   /**
    * Return the source information associated with the given source, or `null` if the source
    * is not known to this context. This method should be used to access the source information
    * rather than accessing the source map directly because sources in the SDK are implicitly part of
    * every analysis context and are therefore only added to the map when first accessed.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
@@ skipping 158 matching lines @@
   /**
    * Invalidate all of the results computed by this context.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    */
   void invalidateAllResults() {
     for (MapEntry<Source, SourceEntry> mapEntry in getMapEntrySet(_sourceMap)) {
       SourceEntry sourceEntry = mapEntry.getValue();
       if (sourceEntry is HtmlEntry) {
         HtmlEntryImpl htmlCopy = ((sourceEntry as HtmlEntry)).writableCopy;
-        htmlCopy.setState(HtmlEntry.RESOLVED_UNIT, CacheState.INVALID);
+        htmlCopy.invalidateAllResolutionInformation();
         mapEntry.setValue(htmlCopy);
       } else if (sourceEntry is DartEntry) {
         DartEntryImpl dartCopy = ((sourceEntry as DartEntry)).writableCopy;
         dartCopy.invalidateAllResolutionInformation();
         mapEntry.setValue(dartCopy);
       }
     }
   }
 
   /**
@@ skipping 67 matching lines @@
           return true;
         } else if (identical(dartEntry.getState(DartEntry.RESOLVED_UNIT), CacheState.INVALID)) {
           safelyResolveCompilationUnit(source);
           return true;
         }
       } else if (sourceEntry is HtmlEntry) {
         HtmlEntry htmlEntry = sourceEntry as HtmlEntry;
         if (identical(htmlEntry.getState(HtmlEntry.PARSED_UNIT), CacheState.INVALID)) {
           safelyParseHtmlUnit(source);
           return true;
-        } else if (identical(htmlEntry.getState(HtmlEntry.RESOLVED_UNIT), CacheState.INVALID)) {
+        } else if (identical(htmlEntry.getState(HtmlEntry.ELEMENT), CacheState.INVALID)) {
           safelyResolveHtmlUnit(source);
           return true;
         }
       }
     }
     for (MapEntry<Source, SourceEntry> entry in getMapEntrySet(_sourceMap)) {
       SourceEntry sourceEntry = entry.getValue();
       if (sourceEntry is DartEntry) {
         DartEntry dartEntry = sourceEntry as DartEntry;
-        CacheState parsedUnitState = dartEntry.getState(DartEntry.PARSED_UNIT);
-        if (identical(parsedUnitState, CacheState.INVALID)) {
+        if (identical(dartEntry.getState(DartEntry.PARSED_UNIT), CacheState.INVALID)) {
           safelyParseCompilationUnit(entry.getKey(), dartEntry);
           return true;
         }
       } else if (sourceEntry is HtmlEntry) {
         HtmlEntry htmlEntry = sourceEntry as HtmlEntry;
-        CacheState parsedUnitState = htmlEntry.getState(HtmlEntry.PARSED_UNIT);
-        if (identical(parsedUnitState, CacheState.INVALID)) {
+        if (identical(htmlEntry.getState(HtmlEntry.PARSED_UNIT), CacheState.INVALID)) {
           safelyParseHtmlUnit(entry.getKey());
           return true;
         }
       }
     }
     for (MapEntry<Source, SourceEntry> entry in getMapEntrySet(_sourceMap)) {
       SourceEntry sourceEntry = entry.getValue();
       if (sourceEntry is DartEntry && identical(sourceEntry.kind, SourceKind.LIBRARY)) {
         DartEntry dartEntry = sourceEntry as DartEntry;
-        CacheState elementState = dartEntry.getState(DartEntry.ELEMENT);
-        if (identical(elementState, CacheState.INVALID)) {
+        if (identical(dartEntry.getState(DartEntry.ELEMENT), CacheState.INVALID)) {
           safelyResolveCompilationUnit(entry.getKey());
           return true;
         }
       } else if (sourceEntry is HtmlEntry) {
         HtmlEntry htmlEntry = sourceEntry as HtmlEntry;
-        CacheState resolvedUnitState = htmlEntry.getState(HtmlEntry.RESOLVED_UNIT);
-        if (identical(resolvedUnitState, CacheState.INVALID)) {
+        if (identical(htmlEntry.getState(HtmlEntry.ELEMENT), CacheState.INVALID)) {
           safelyResolveHtmlUnit(entry.getKey());
           return true;
         }
       }
     }
     return false;
   }
 
   /**
    * Given a cache entry and a library element, record the library element and other information
@@ skipping 155 matching lines @@
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source that has been added
    * @return `true` if the new source is a Dart file
    */
   bool sourceAvailable(Source source) {
     SourceEntry sourceEntry = _sourceMap[source];
     if (sourceEntry == null) {
       sourceEntry = createSourceEntry(source);
+    } else {
+      SourceEntryImpl sourceCopy = sourceEntry.writableCopy;
+      sourceCopy.modificationTime = source.modificationStamp;
+      _sourceMap[source] = sourceCopy;
     }
     return sourceEntry is DartEntry;
   }
 
   /**
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source that has been changed
    */
   void sourceChanged(Source source) {
     SourceEntry sourceEntry = _sourceMap[source];
     if (sourceEntry is HtmlEntry) {
       HtmlEntryImpl htmlCopy = ((sourceEntry as HtmlEntry)).writableCopy;
+      htmlCopy.modificationTime = source.modificationStamp;
       htmlCopy.setState(HtmlEntry.ELEMENT, CacheState.INVALID);
       htmlCopy.setState(SourceEntry.LINE_INFO, CacheState.INVALID);
       htmlCopy.setState(HtmlEntry.PARSED_UNIT, CacheState.INVALID);
       htmlCopy.setState(HtmlEntry.REFERENCED_LIBRARIES, CacheState.INVALID);
-      htmlCopy.setState(HtmlEntry.RESOLVED_UNIT, CacheState.INVALID);
+      htmlCopy.setState(HtmlEntry.RESOLUTION_ERRORS, CacheState.INVALID);
       _sourceMap[source] = htmlCopy;
     } else if (sourceEntry is DartEntry) {
       List<Source> containingLibraries = getLibrariesContaining(source);
       DartEntryImpl dartCopy = ((sourceEntry as DartEntry)).writableCopy;
+      dartCopy.modificationTime = source.modificationStamp;
       dartCopy.setState(SourceEntry.LINE_INFO, CacheState.INVALID);
       dartCopy.setState(DartEntry.PARSE_ERRORS, CacheState.INVALID);
       dartCopy.setState(DartEntry.PARSED_UNIT, CacheState.INVALID);
       dartCopy.setState(DartEntry.SOURCE_KIND, CacheState.INVALID);
       _sourceMap[source] = dartCopy;
       for (Source library in containingLibraries) {
         invalidateLibraryResolution(library);
       }
     }
   }
@@ skipping 33 matching lines @@
     }
     return new List.from(sources);
   }
 }
 /**
  * Instances of the class `ScanResult` represent the results of scanning a source.
  */
 class AnalysisContextImpl_ScanResult {
 
   /**
-   * The time at which the contents of the source were last set.
+   * The time at which the contents of the source were last modified.
    */
   int _modificationTime = 0;
 
   /**
    * The first token in the token stream.
    */
   Token _token;
 
   /**
    * The line start information that was produced.
    */
   List<int> _lineStarts;
+
+  /**
+   * Return the time at which the contents of the source were last modified.
+   *
+   * @return the time at which the contents of the source were last modified
+   */
+  int get modificationTime => _modificationTime;
 }
 class RecursiveXmlVisitor_6 extends RecursiveXmlVisitor<Object> {
   final AnalysisContextImpl AnalysisContextImpl_this;
   Source htmlSource;
   List<Source> libraries;
   RecursiveXmlVisitor_6(this.AnalysisContextImpl_this, this.htmlSource, this.libraries) : super();
   Object visitXmlTagNode(XmlTagNode node) {
     if (javaStringEqualsIgnoreCase(node.tag.lexeme, AnalysisContextImpl._TAG_SCRIPT)) {
       bool isDartScript = false;
       XmlAttributeNode scriptAttribute = null;
@@ skipping 88 matching lines @@
  */
 class AnalysisOptionsImpl implements AnalysisOptions {
 
   /**
    * A flag indicating whether analysis is to use strict mode. In strict mode, error reporting is
    * based exclusively on the static type information.
    */
   bool _strictMode = false;
 
   /**
-   * A flag indicating whether analysis is to generate audit results (e.g. type inference based
+   * A flag indicating whether analysis is to generate hint results (e.g. type inference based
    * information and pub best practices).
    */
-  bool _audit = true;
-  bool get audit => _audit;
+  bool _hint = true;
+  bool get hint => _hint;
 
   /**
    * Return `true` if analysis is to use strict mode. In strict mode, error reporting is based
    * exclusively on the static type information.
    *
    * @return `true` if analysis is to use strict mode
    */
   bool get strictMode => _strictMode;
 
   /**
-   * Set whether analysis is to generate audit results (e.g. type inference based information and
-   * pub best practices).
+   * Set whether analysis is to generate hint results (e.g. type inference based information and pub
+   * best practices).
    *
-   * @param audit `true` if analysis is to generate audit results
+   * @param hint `true` if analysis is to generate hint results
    */
-  void set audit(bool audit2) {
-    this._audit = audit2;
+  void set hint(bool hint2) {
+    this._hint = hint2;
   }
 
   /**
    * Set whether analysis is to use strict mode to the given value. In strict mode, error reporting
    * is based exclusively on the static type information.
    *
    * @param isStrict `true` if analysis is to use strict mode
    */
   void set strictMode(bool isStrict) {
     _strictMode = isStrict;
@@ skipping 58 matching lines @@
    *
    */
   static final CacheState VALID = new CacheState('VALID', 4);
   static final List<CacheState> values = [ERROR, FLUSHED, IN_PROCESS, INVALID, VALID];
 
   /// The name of this enum constant, as declared in the enum declaration.
   final String name;
 
   /// The position in the enum declaration.
   final int ordinal;
-  CacheState(this.name, this.ordinal) {
-  }
+  CacheState(this.name, this.ordinal);
   int compareTo(CacheState other) => ordinal - other.ordinal;
   int get hashCode => ordinal;
   String toString() => name;
 }
 /**
  * Instances of the class `ChangeNoticeImpl` represent a change to the analysis results
  * associated with a given source.
  *
  * @coverage dart.engine
  */
@@ skipping 360 matching lines @@
 
   /**
    * The analysis context to which all of the non-instrumentation work is delegated.
    */
   InternalAnalysisContext _basis;
 
   /**
    * Create a new [InstrumentedAnalysisContextImpl] which wraps a new
    * [AnalysisContextImpl] as the basis context.
    */
-  InstrumentedAnalysisContextImpl() {
-    _jtd_constructor_185_impl();
-  }
-  _jtd_constructor_185_impl() {
-    _jtd_constructor_186_impl(new AnalysisContextImpl());
-  }
+  InstrumentedAnalysisContextImpl() : this.con1(new AnalysisContextImpl());
 
   /**
    * Create a new [InstrumentedAnalysisContextImpl] with a specified basis context, aka the
    * context to wrap and instrument.
    *
    * @param context some [InstrumentedAnalysisContext] to wrap and instrument
    */
   InstrumentedAnalysisContextImpl.con1(InternalAnalysisContext context) {
-    _jtd_constructor_186_impl(context);
-  }
-  _jtd_constructor_186_impl(InternalAnalysisContext context) {
     _basis = context;
   }
   void addSourceInfo(Source source, SourceEntry info) {
     _basis.addSourceInfo(source, info);
   }
   void applyChanges(ChangeSet changeSet) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-applyChanges");
     try {
       instrumentation.metric3("contextId", _contextId);
       _basis.applyChanges(changeSet);
@@ skipping 723 matching lines @@
   }
   void logError2(String message, Exception exception) {
   }
   void logError3(Exception exception) {
   }
   void logInformation(String message) {
   }
   void logInformation2(String message, Exception exception) {
   }
 }