New analyzer snapshot.

pkg/analyzer/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 'java_core.dart';
 import 'java_engine.dart';
 import 'utilities_collection.dart';
 import 'utilities_general.dart';
 import 'instrumentation.dart';
 import 'error.dart';
 import 'source.dart';
 import 'scanner.dart' show Token, Scanner, CharSequenceReader;
 import 'ast.dart';
 import 'parser.dart' show Parser;
 import 'sdk.dart' show DartSdk;
 import 'element.dart';
 import 'resolver.dart';
 import 'html.dart' show XmlTagNode, XmlAttributeNode, RecursiveXmlVisitor, HtmlScanner, HtmlScanResult, HtmlParser, HtmlParseResult, HtmlUnit;
+
 /**
  * The unique instance of the class `AnalysisEngine` serves as the entry point for the
  * functionality provided by the analysis engine.
  *
  * @coverage dart.engine
  */
 class AnalysisEngine {
-
   /**
    * The suffix used for Dart source files.
    */
   static String SUFFIX_DART = "dart";
 
   /**
    * The short suffix used for HTML files.
    */
   static String SUFFIX_HTM = "htm";
 
@@ skipping 62 matching lines @@
    * Set the logger that should receive information about errors within the analysis engine to the
    * given logger.
    *
    * @param logger the logger that should receive information about errors within the analysis
    *          engine
    */
   void set logger(Logger logger) {
     this._logger = logger == null ? Logger.NULL : logger;
   }
 }
+
 /**
  * Container with statistics about the [AnalysisContext].
  */
 abstract class AnalysisContentStatistics {
-
   /**
    * 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<AnalysisException> get exceptions;
 
   /**
    * Return the statistics for each kind of cached data.
    *
    * @return the statistics for each kind of cached data
    */
   List<AnalysisContentStatistics_CacheRow> get cacheRows;
 }
+
 /**
  * Information about single item in the cache.
  */
 abstract class AnalysisContentStatistics_CacheRow {
   int get errorCount;
+
   int get flushedCount;
+
   int get inProcessCount;
+
   int get invalidCount;
+
   String get name;
+
   int get validCount;
 }
+
 /**
  * The interface `AnalysisContext` defines the behavior of objects that represent a context in
  * which a single analysis can be performed and incrementally maintained. The context includes such
  * information as the version of the SDK being analyzed against as well as the package-root used to
  * resolve 'package:' URI's. (Both of which are known indirectly through the [SourceFactory
  ].)
  *
  * An analysis context also represents the state of the analysis, which includes knowing which
  * sources have been included in the analysis (either directly or indirectly) and the results of the
  * analysis. Sources must be added and removed from the context using the method
@@ skipping 15 matching lines @@
  * up-to-date. For such clients there is a mechanism that allows them to incrementally perform
  * needed analysis and get notified of the consequent changes to the analysis results. This
  * mechanism is realized by the method [performAnalysisTask].
  *
  * Analysis engine allows for having more than one context. This can be used, for example, to
  * perform one analysis based on the state of files on disk and a separate analysis based on the
  * state of those files in open editors. It can also be used to perform an analysis based on a
  * proposed future state, such as the state after a refactoring.
  */
 abstract class AnalysisContext {
-
   /**
    * Apply the changes specified by the given change set to this context. Any analysis results that
    * have been invalidated by these changes will be removed.
    *
    * @param changeSet a description of the changes that are to be applied
    */
   void applyChanges(ChangeSet changeSet);
 
   /**
    * Return the documentation comment for the given element as it appears in the original source
@@ skipping 429 matching lines @@
 
   /**
    * Given a collection of sources with content that has changed, return an [Iterable]
    * identifying the sources that need to be resolved.
    *
    * @param changedSources an array of sources (not `null`, contains no `null`s)
    * @return An iterable returning the sources to be resolved
    */
   Iterable<Source> sourcesToResolve(List<Source> changedSources);
 }
+
 /**
  * The interface `AnalysisErrorInfo` contains the analysis errors and line information for the
  * errors.
  */
 abstract class AnalysisErrorInfo {
-
   /**
    * Return the errors that as a result of the analysis, or `null` if there were no errors.
    *
    * @return the errors as a result of the analysis
    */
   List<AnalysisError> get errors;
 
   /**
    * Return the line information associated with the errors, or `null` if there were no
    * errors.
    *
    * @return the line information associated with the errors
    */
   LineInfo get lineInfo;
 }
+
 /**
  * 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();
 
   /**
    * Initialize a newly created exception to have the given message.
    *
    * @param message the message associated with the exception
    */
   AnalysisException.con1(String message) : super(message);
 
   /**
    * Initialize a newly created exception to have the given message and cause.
    *
    * @param message the message associated with the exception
    * @param cause the underlying exception that caused this exception
    */
   AnalysisException.con2(String message, Exception cause) : super(message, cause);
 
   /**
    * Initialize a newly created exception to have the given cause.
    *
    * @param cause the underlying exception that caused this exception
    */
   AnalysisException.con3(Exception cause) : super.withCause(cause);
 }
+
 /**
  * The 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 the maximum number of sources for which AST structures should be kept in the cache.
    *
    * @return the maximum number of sources for which AST structures should be kept in the cache
    */
   int get cacheSize;
 
   /**
    * Return `true` if analysis is to generate dart2js related hint results.
    *
@@ skipping 10 matching lines @@
   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;
 }
+
 /**
  * Instances of the class `AnalysisResult`
  */
 class AnalysisResult {
-
   /**
    * The change notices associated with this result, or `null` if there were no changes and
    * there is no more work to be done.
    */
   List<ChangeNotice> changeNotices;
 
   /**
    * The number of milliseconds required to determine which task was to be performed.
    */
   int getTime = 0;
@@ skipping 16 matching lines @@
    * @param taskClassName the name of the class of the task that was performed
    * @param performTime the number of milliseconds required to perform the task
    */
   AnalysisResult(List<ChangeNotice> notices, int getTime, String taskClassName, int performTime) {
     this.changeNotices = notices;
     this.getTime = getTime;
     this.taskClassName = taskClassName;
     this.performTime = performTime;
   }
 }
+
 /**
  * The interface `ChangeNotice` defines the behavior of objects that represent a change to the
  * analysis results associated with a given source.
  *
  * @coverage dart.engine
  */
 abstract class ChangeNotice implements AnalysisErrorInfo {
-
   /**
    * Return the fully resolved AST that changed as a result of the analysis, or `null` if the
    * AST was not changed.
    *
    * @return the fully resolved AST that changed as a result of the analysis
    */
   CompilationUnit get compilationUnit;
 
   /**
    * Return the source for which the result is being reported.
    *
    * @return the source for which the result is being reported
    */
   Source get source;
 }
+
 /**
  * Instances of the class `ChangeSet` indicate what sources have been added, changed, or
  * removed.
  *
  * @coverage dart.engine
  */
 class ChangeSet {
-
   /**
    * A list containing the sources that have been added.
    */
   final List<Source> added3 = new List<Source>();
 
   /**
    * A list containing the sources that have been changed.
    */
   final List<Source> changed3 = new List<Source>();
 
@@ skipping 48 matching lines @@
   /**
    * Record that the specified source container has been removed.
    *
    * @param container the source container that was removed
    */
   void removedContainer(SourceContainer container) {
     if (container != null) {
       removedContainers.add(container);
     }
   }
+
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
     bool needsSeparator = appendSources(builder, added3, false, "added");
     needsSeparator = appendSources(builder, changed3, needsSeparator, "changed");
     appendSources(builder, removed3, needsSeparator, "removed");
     int count = removedContainers.length;
     if (count > 0) {
       if (removed3.isEmpty) {
         if (needsSeparator) {
           builder.append("; ");
@@ skipping 30 matching lines @@
     builder.append(label);
     String prefix = " ";
     for (Source source in sources) {
       builder.append(prefix);
       builder.append(source.fullName);
       prefix = ", ";
     }
     return true;
   }
 }
+
 /**
  * Instances of the class `AnalysisCache` implement an LRU cache of information related to
  * analysis.
  */
 class AnalysisCache {
-
   /**
    * A table mapping the sources known to the context to the information known about the source.
    */
   Map<Source, SourceEntry> _sourceMap = new Map<Source, SourceEntry>();
 
   /**
    * The maximum number of sources for which AST structures should be kept in the cache.
    */
   int _maxCacheSize = 0;
 
@@ skipping 103 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 htmlCopy = ((sourceEntry as HtmlEntry)).writableCopy;
+      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;
+      DartEntryImpl dartCopy = (sourceEntry as DartEntry).writableCopy;
       dartCopy.flushAstStructures();
       _sourceMap[removedSource] = dartCopy;
     }
     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 11 matching lines @@
         sourceToRemove = i;
       }
     }
     if (sourceToRemove < 0) {
       AnalysisEngine.instance.logger.logError2("Internal error: Could not flush data from the cache", new JavaException());
       return null;
     }
     return _recentlyUsed.removeAt(sourceToRemove);
   }
 }
+
 /**
  * Instances of the class `CacheRetentionPolicy` define the behavior of objects that determine
  * how important it is for data to be retained in the analysis cache.
  */
 abstract class CacheRetentionPolicy {
-
   /**
    * Return the priority of retaining the AST structure for the given source.
    *
    * @param source the source whose AST structure is being considered for removal
    * @param sourceEntry the entry representing the source
    * @return the priority of retaining the AST structure for the given source
    */
   RetentionPriority getAstPriority(Source source, SourceEntry sourceEntry);
 }
+
 /**
  * The enumeration `CacheState` defines the possible states of cached data.
  */
 class CacheState extends Enum<CacheState> {
-
   /**
    * The data is not in the cache and the last time an attempt was made to compute the data an
    * exception occurred, making it pointless to attempt.
    *
    * Valid Transitions:
    *
    * * [INVALID] if a source was modified that might cause the data to be computable
    *
    */
   static final CacheState ERROR = new CacheState('ERROR', 0);
@@ skipping 34 matching lines @@
   /**
    * The data is in the cache and up-to-date.
    *
    * Valid Transitions:
    *
    * * [FLUSHED] if the data is removed in order to manage memory usage
    * * [INVALID] if a source was modified in such a way as to invalidate the previous data
    *
    */
   static final CacheState VALID = new CacheState('VALID', 4);
+
   static final List<CacheState> values = [ERROR, FLUSHED, IN_PROCESS, INVALID, VALID];
+
   CacheState(String name, int ordinal) : super(name, ordinal);
 }
+
 /**
  * The interface `DartEntry` defines the behavior of objects that maintain the information
  * cached by an analysis context about an individual Dart file.
  *
  * @coverage dart.engine
  */
 abstract class DartEntry implements SourceEntry {
-
   /**
    * 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.
    */
@@ skipping 102 matching lines @@
   /**
    * 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 getValue2(DataDescriptor descriptor, Source librarySource);
+
   DartEntryImpl get writableCopy;
 
   /**
    * 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 data is safe to use in refactoring.
    */
   bool get isRefactoringSafe;
 }
+
 /**
  * Instances of the class `DartEntryImpl` implement a [DartEntry].
  *
  * @coverage dart.engine
  */
 class DartEntryImpl extends SourceEntryImpl implements DartEntry {
-
   /**
    * The state of the cached source kind.
    */
   CacheState _sourceKindState = CacheState.INVALID;
 
   /**
    * The kind of this source.
    */
   SourceKind _sourceKind = SourceKind.UNKNOWN;
 
@@ skipping 116 matching lines @@
    * Flush any AST structures being maintained by this entry.
    */
   void flushAstStructures() {
     if (identical(_parsedUnitState, CacheState.VALID)) {
       _parsedUnitState = CacheState.FLUSHED;
       _parsedUnitAccessed = false;
       _parsedUnit = null;
     }
     _resolutionState.flushAstStructures();
   }
+
   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._verificationErrors) {
         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)) {
       _parsedUnitAccessed = true;
       return _parsedUnit;
     }
     return anyResolvedCompilationUnit;
   }
+
   CompilationUnit get anyResolvedCompilationUnit {
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
       if (identical(state._resolvedUnitState, CacheState.VALID)) {
         return state._resolvedUnit;
       }
       state = state._nextState;
     }
     ;
     return null;
   }
+
   SourceKind get kind => _sourceKind;
 
   /**
    * Answer an array of library sources containing the receiver's source.
    */
   List<Source> get librariesContaining {
     DartEntryImpl_ResolutionState state = _resolutionState;
     List<Source> result = new List<Source>();
     while (state != null) {
       if (state._librarySource != null) {
@@ skipping 24 matching lines @@
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
       if (identical(state._resolvedUnitState, CacheState.VALID)) {
         return state._resolvedUnit.accept(new ASTCloner()) as CompilationUnit;
       }
       state = state._nextState;
     }
     ;
     return null;
   }
+
   CacheState getState(DataDescriptor descriptor) {
     if (identical(descriptor, DartEntry.ELEMENT)) {
       return _elementState;
     } else if (identical(descriptor, DartEntry.EXPORTED_LIBRARIES)) {
       return _exportedLibrariesState;
     } else if (identical(descriptor, DartEntry.IMPORTED_LIBRARIES)) {
       return _importedLibrariesState;
     } else if (identical(descriptor, DartEntry.INCLUDED_PARTS)) {
       return _includedPartsState;
     } else if (identical(descriptor, DartEntry.IS_CLIENT)) {
       return _clientServerState;
     } else if (identical(descriptor, DartEntry.IS_LAUNCHABLE)) {
       return _launchableState;
     } else if (identical(descriptor, DartEntry.PARSE_ERRORS)) {
       return _parseErrorsState;
     } else if (identical(descriptor, DartEntry.PARSED_UNIT)) {
       return _parsedUnitState;
     } else if (identical(descriptor, DartEntry.PUBLIC_NAMESPACE)) {
       return _publicNamespaceState;
     } else if (identical(descriptor, DartEntry.SOURCE_KIND)) {
       return _sourceKindState;
     } else {
       return super.getState(descriptor);
     }
   }
+
   CacheState getState2(DataDescriptor descriptor, Source librarySource) {
     DartEntryImpl_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)) {
       return CacheState.INVALID;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
+
   Object getValue(DataDescriptor descriptor) {
     if (identical(descriptor, DartEntry.ELEMENT)) {
       return _element as Object;
     } else if (identical(descriptor, DartEntry.EXPORTED_LIBRARIES)) {
       return _exportedLibraries as Object;
     } else if (identical(descriptor, DartEntry.IMPORTED_LIBRARIES)) {
       return _importedLibraries as Object;
     } else if (identical(descriptor, DartEntry.INCLUDED_PARTS)) {
       return _includedParts as Object;
     } else if (identical(descriptor, DartEntry.IS_CLIENT)) {
       return (BooleanArray.get2(_bitmask, _CLIENT_CODE_INDEX) as bool) as Object;
     } else if (identical(descriptor, DartEntry.IS_LAUNCHABLE)) {
       return (BooleanArray.get2(_bitmask, _LAUNCHABLE_INDEX) as bool) as Object;
     } else if (identical(descriptor, DartEntry.PARSE_ERRORS)) {
       return _parseErrors as Object;
     } else if (identical(descriptor, DartEntry.PARSED_UNIT)) {
       _parsedUnitAccessed = true;
       return _parsedUnit as Object;
     } else if (identical(descriptor, DartEntry.PUBLIC_NAMESPACE)) {
       return _publicNamespace as Object;
     } else if (identical(descriptor, DartEntry.SOURCE_KIND)) {
       return _sourceKind as Object;
     }
     return super.getValue(descriptor);
   }
+
   Object getValue2(DataDescriptor descriptor, Source librarySource) {
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
       if (librarySource == 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.VERIFICATION_ERRORS)) {
           return state._verificationErrors 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) || identical(descriptor, DartEntry.VERIFICATION_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);
     return copy;
   }
+
   bool hasInvalidData(DataDescriptor descriptor) {
     if (identical(descriptor, DartEntry.ELEMENT)) {
       return identical(_elementState, CacheState.INVALID);
     } else if (identical(descriptor, DartEntry.EXPORTED_LIBRARIES)) {
       return identical(_exportedLibrariesState, CacheState.INVALID);
     } else if (identical(descriptor, DartEntry.IMPORTED_LIBRARIES)) {
       return identical(_importedLibrariesState, CacheState.INVALID);
     } else if (identical(descriptor, DartEntry.INCLUDED_PARTS)) {
       return identical(_includedPartsState, CacheState.INVALID);
     } else if (identical(descriptor, DartEntry.IS_CLIENT)) {
@@ skipping 53 matching lines @@
           _parsedUnit = state._resolvedUnit;
           _parsedUnitAccessed = true;
           _parsedUnitState = CacheState.VALID;
           break;
         }
         state = state._nextState;
       }
     }
     discardCachedResolutionInformation();
   }
+
   bool get isRefactoringSafe {
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
       CacheState resolvedState = state._resolvedUnitState;
       if (resolvedState != CacheState.VALID && resolvedState != CacheState.FLUSHED) {
         return false;
       }
       state = state._nextState;
     }
     return true;
@@ skipping 160 matching lines @@
     if (_parsedUnitState != CacheState.VALID) {
       _parsedUnit = unit;
       _parsedUnitAccessed = false;
       _parsedUnitState = CacheState.VALID;
     }
     if (_parseErrorsState != CacheState.VALID) {
       _parseErrors = errors == null ? AnalysisError.NO_ERRORS : errors;
       _parseErrorsState = CacheState.VALID;
     }
   }
+
   void setState(DataDescriptor descriptor, CacheState state) {
     if (identical(descriptor, DartEntry.ELEMENT)) {
       _element = updatedValue(state, _element, null);
       _elementState = state;
     } else if (identical(descriptor, DartEntry.EXPORTED_LIBRARIES)) {
       _exportedLibraries = updatedValue(state, _exportedLibraries, Source.EMPTY_ARRAY);
       _exportedLibrariesState = state;
     } else if (identical(descriptor, DartEntry.IMPORTED_LIBRARIES)) {
       _importedLibraries = updatedValue(state, _importedLibraries, Source.EMPTY_ARRAY);
       _importedLibrariesState = state;
@@ skipping 47 matching lines @@
     } 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)) {
       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>);
       _exportedLibrariesState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.IMPORTED_LIBRARIES)) {
       _importedLibraries = value == null ? Source.EMPTY_ARRAY : (value as List<Source>);
       _importedLibrariesState = CacheState.VALID;
@@ skipping 42 matching lines @@
       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;
     }
   }
+
   void copyFrom(SourceEntryImpl entry) {
     super.copyFrom(entry);
     DartEntryImpl other = entry as DartEntryImpl;
     _sourceKindState = other._sourceKindState;
     _sourceKind = other._sourceKind;
     _parsedUnitState = other._parsedUnitState;
     _parsedUnit = other._parsedUnit;
     _parsedUnitAccessed = other._parsedUnitAccessed;
     _parseErrorsState = other._parseErrorsState;
     _parseErrors = other._parseErrors;
     _includedPartsState = other._includedPartsState;
     _includedParts = other._includedParts;
     _exportedLibrariesState = other._exportedLibrariesState;
     _exportedLibraries = other._exportedLibraries;
     _importedLibrariesState = other._importedLibrariesState;
     _importedLibraries = other._importedLibraries;
     _resolutionState.copyFrom(other._resolutionState);
     _elementState = other._elementState;
     _element = other._element;
     _publicNamespaceState = other._publicNamespaceState;
     _publicNamespace = other._publicNamespace;
     _clientServerState = other._clientServerState;
     _launchableState = other._launchableState;
     _bitmask = other._bitmask;
   }
+
   void writeOn(JavaStringBuilder builder) {
     builder.append("Dart: ");
     super.writeOn(builder);
     builder.append("; sourceKind = ");
     builder.append(_sourceKindState);
     builder.append("; parsedUnit = ");
     builder.append(_parsedUnitState);
     builder.append(" (");
     builder.append(_parsedUnitAccessed ? "T" : "F");
     builder.append("); parseErrors = ");
@@ skipping 70 matching lines @@
    */
   int updatedValue2(CacheState state, int currentValue, int bitIndex) {
     if (identical(state, CacheState.VALID)) {
       throw new IllegalArgumentException("Use setValue() to set the state to VALID");
     } else if (identical(state, CacheState.IN_PROCESS)) {
       return currentValue;
     }
     return BooleanArray.set2(currentValue, bitIndex, 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.
    */
@@ skipping 150 matching lines @@
       builder.append("; verificationErrors = ");
       builder.append(_verificationErrorsState);
       builder.append("; hints = ");
       builder.append(_hintsState);
       if (_nextState != null) {
         _nextState.writeOn(builder);
       }
     }
   }
 }
+
 /**
  * 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.
    */
   String _name;
 
   /**
    * Initialize a newly created descriptor to have the given name.
    *
    * @param name the name of the descriptor
    */
   DataDescriptor(String name) {
     this._name = name;
   }
+
   String toString() => _name;
 }
+
 /**
  * The interface `HtmlEntry` defines the behavior of objects that maintain the information
  * cached by an analysis context about an individual HTML file.
  *
  * @coverage dart.engine
  */
 abstract class HtmlEntry implements SourceEntry {
-
   /**
    * 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>>("DartEntry.HINTS");
 
@@ skipping 11 matching lines @@
    * 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");
 
   /**
    * 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].
  *
  * @coverage dart.engine
  */
 class HtmlEntryImpl extends SourceEntryImpl implements HtmlEntry {
-
   /**
    * 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.
    */
   HtmlUnit _parsedUnit;
 
@@ skipping 32 matching lines @@
   /**
    * 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;
+
   List<AnalysisError> get allErrors {
     List<AnalysisError> errors = new List<AnalysisError>();
     for (AnalysisError error in _resolutionErrors) {
       errors.add(error);
     }
     for (AnalysisError error in _hints) {
       errors.add(error);
     }
     if (errors.length == 0) {
       return AnalysisError.NO_ERRORS;
     }
     return new List.from(errors);
   }
+
   SourceKind get kind => SourceKind.HTML;
+
   CacheState getState(DataDescriptor 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.HINTS)) {
       return _hintsState;
     }
     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.HINTS)) {
       return _hints as Object;
     }
     return super.getValue(descriptor);
   }
+
   HtmlEntryImpl get writableCopy {
     HtmlEntryImpl copy = new HtmlEntryImpl();
     copy.copyFrom(this);
     return copy;
   }
 
   /**
    * Invalidate all of the information associated with the HTML file.
    */
   void invalidateAllInformation() {
@@ skipping 11 matching lines @@
   void invalidateAllResolutionInformation() {
     _element = null;
     _elementState = CacheState.INVALID;
     _resolutionErrors = AnalysisError.NO_ERRORS;
     _resolutionErrorsState = CacheState.INVALID;
     _hints = AnalysisError.NO_ERRORS;
     _hintsState = CacheState.INVALID;
   }
 
   /**
+   * Record that an error was encountered while attempting to parse the source associated with this
+   * entry.
+   */
+  void recordParseError() {
+    setState(SourceEntry.LINE_INFO, CacheState.ERROR);
+    setState(HtmlEntry.PARSED_UNIT, CacheState.ERROR);
+    setState(HtmlEntry.REFERENCED_LIBRARIES, CacheState.ERROR);
+    recordResolutionError();
+  }
+
+  /**
    * Record that an error was encountered while attempting to resolve the source associated with
    * this entry.
    */
   void recordResolutionError() {
     setState(HtmlEntry.ELEMENT, CacheState.ERROR);
     setState(HtmlEntry.RESOLUTION_ERRORS, CacheState.ERROR);
+    setState(HtmlEntry.HINTS, CacheState.ERROR);
   }
+
   void setState(DataDescriptor 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.HINTS)) {
       _hints = updatedValue(state, _hints, AnalysisError.NO_ERRORS);
       _hintsState = 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.HINTS)) {
       _hints = value as List<AnalysisError>;
       _hintsState = 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;
     _elementState = other._elementState;
     _element = other._element;
     _hints = other._hints;
     _hintsState = other._hintsState;
   }
+
   void writeOn(JavaStringBuilder builder) {
     builder.append("Html: ");
     super.writeOn(builder);
     builder.append("; parsedUnit = ");
     builder.append(_parsedUnitState);
     builder.append("; resolutionErrors = ");
     builder.append(_resolutionErrorsState);
     builder.append("; referencedLibraries = ");
     builder.append(_referencedLibrariesState);
     builder.append("; element = ");
     builder.append(_elementState);
   }
 }
+
 /**
  * The enumerated type `RetentionPriority` represents the priority of data in the cache in
  * terms of the desirability of retaining some specified data about a specified source.
  */
 class RetentionPriority extends Enum<RetentionPriority> {
-
   /**
    * A priority indicating that a given piece of data can be removed from the cache without
    * reservation.
    */
   static final RetentionPriority LOW = new RetentionPriority('LOW', 0);
 
   /**
    * A priority indicating that a given piece of data should not be removed from the cache unless
    * there are no sources for which the corresponding data has a lower priority. Currently used for
    * data that is needed in order to finish some outstanding analysis task.
    */
   static final RetentionPriority MEDIUM = new RetentionPriority('MEDIUM', 1);
 
   /**
    * A priority indicating that a given piece of data should not be removed from the cache.
    * Currently used for data related to a priority source.
    */
   static final RetentionPriority HIGH = new RetentionPriority('HIGH', 2);
+
   static final List<RetentionPriority> values = [LOW, MEDIUM, HIGH];
+
   RetentionPriority(String name, int ordinal) : super(name, ordinal);
 }
+
 /**
  * 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.
  *
  * @coverage dart.engine
  */
 abstract class SourceEntry {
-
   /**
    * 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
@@ skipping 33 matching lines @@
   Object getValue(DataDescriptor descriptor);
 
   /**
    * Return a new entry that is initialized to the same state as this entry but that can be
    * modified.
    *
    * @return a writable copy of this entry
    */
   SourceEntryImpl get writableCopy;
 }
+
 /**
  * Instances of the abstract class `SourceEntryImpl` implement the behavior common to all
  * [SourceEntry].
  *
  * @coverage dart.engine
  */
 abstract class SourceEntryImpl implements SourceEntry {
-
   /**
    * The most recent time at which the state of the source matched the state represented by this
    * entry.
    */
   int _modificationTime = 0;
 
   /**
    * The exception that caused one or more values to have a state of [CacheState#ERROR].
    */
   AnalysisException _exception;
 
   /**
    * 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.
    */
   LineInfo _lineInfo;
 
   /**
    * Return the exception that caused one or more values to have a state of [CacheState#ERROR]
    * .
    *
    * @return the exception that caused one or more values to be uncomputable
    */
   AnalysisException get exception => _exception;
+
   int get modificationTime => _modificationTime;
+
   CacheState getState(DataDescriptor descriptor) {
     if (identical(descriptor, SourceEntry.LINE_INFO)) {
       return _lineInfoState;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
+
   Object getValue(DataDescriptor descriptor) {
     if (identical(descriptor, SourceEntry.LINE_INFO)) {
       return _lineInfo as Object;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
 
   /**
    * Set the exception that caused one or more values to have a state of [CacheState#ERROR] to
@@ skipping 37 matching lines @@
    * @param value the new value of the data represented by the given descriptor
    */
   void setValue(DataDescriptor descriptor, Object value) {
     if (identical(descriptor, SourceEntry.LINE_INFO)) {
       _lineInfo = value as LineInfo;
       _lineInfoState = CacheState.VALID;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
+
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
     writeOn(builder);
     return builder.toString();
   }
 
   /**
    * Copy the information from the given cache entry.
    *
    * @param entry the cache entry from which information will be copied
@@ skipping 28 matching lines @@
    *
    * @param builder the builder to which the text should be written
    */
   void writeOn(JavaStringBuilder builder) {
     builder.append("time = ");
     builder.append(_modificationTime.toRadixString(16));
     builder.append("; lineInfo = ");
     builder.append(_lineInfoState);
   }
 }
+
 /**
  * Implementation of the [AnalysisContentStatistics].
  */
 class AnalysisContentStatisticsImpl implements AnalysisContentStatistics {
   Map<String, AnalysisContentStatistics_CacheRow> _dataMap = new Map<String, AnalysisContentStatistics_CacheRow>();
+
   Set<AnalysisException> _exceptions = new Set<AnalysisException>();
+
   List<AnalysisContentStatistics_CacheRow> get cacheRows {
     Iterable<AnalysisContentStatistics_CacheRow> items = _dataMap.values;
     return new List.from(items);
   }
+
   List<AnalysisException> get exceptions => new List.from(_exceptions);
+
   void putCacheItem(DartEntry dartEntry, DataDescriptor descriptor) {
     putCacheItem3(dartEntry, descriptor, dartEntry.getState(descriptor));
   }
+
   void putCacheItem2(DartEntry dartEntry, Source librarySource, DataDescriptor descriptor) {
     putCacheItem3(dartEntry, descriptor, dartEntry.getState2(descriptor, librarySource));
   }
+
   void putCacheItem3(SourceEntry dartEntry, DataDescriptor rowDesc, CacheState state) {
     String rowName = rowDesc.toString();
     AnalysisContentStatisticsImpl_CacheRowImpl row = _dataMap[rowName] as AnalysisContentStatisticsImpl_CacheRowImpl;
     if (row == null) {
       row = new AnalysisContentStatisticsImpl_CacheRowImpl(rowName);
       _dataMap[rowName] = row;
     }
     row.incState(state);
     if (identical(state, CacheState.ERROR)) {
       AnalysisException exception = dartEntry.exception;
       if (exception != null) {
         javaSetAdd(_exceptions, exception);
       }
     }
   }
 }
+
 class AnalysisContentStatisticsImpl_CacheRowImpl implements AnalysisContentStatistics_CacheRow {
   String _name;
+
   int _errorCount = 0;
+
   int _flushedCount = 0;
+
   int _inProcessCount = 0;
+
   int _invalidCount = 0;
+
   int _validCount = 0;
+
   AnalysisContentStatisticsImpl_CacheRowImpl(String name) {
     this._name = name;
   }
-  bool operator ==(Object obj) => obj is AnalysisContentStatisticsImpl_CacheRowImpl && ((obj as AnalysisContentStatisticsImpl_CacheRowImpl))._name == _name;
+
+  bool operator ==(Object obj) => obj is AnalysisContentStatisticsImpl_CacheRowImpl && (obj as AnalysisContentStatisticsImpl_CacheRowImpl)._name == _name;
+
   int get errorCount => _errorCount;
+
   int get flushedCount => _flushedCount;
+
   int get inProcessCount => _inProcessCount;
+
   int get invalidCount => _invalidCount;
+
   String get name => _name;
+
   int get validCount => _validCount;
+
   int get hashCode => _name.hashCode;
+
   void incState(CacheState state) {
     if (identical(state, CacheState.ERROR)) {
       _errorCount++;
     }
     if (identical(state, CacheState.FLUSHED)) {
       _flushedCount++;
     }
     if (identical(state, CacheState.IN_PROCESS)) {
       _inProcessCount++;
     }
     if (identical(state, CacheState.INVALID)) {
       _invalidCount++;
     }
     if (identical(state, CacheState.VALID)) {
       _validCount++;
     }
   }
 }
+
 /**
  * Instances of the class `AnalysisContextImpl` implement an [AnalysisContext].
  *
  * @coverage dart.engine
  */
 class AnalysisContextImpl implements InternalAnalysisContext {
-
   /**
    * The difference between the maximum cache size and the maximum priority order size. The priority
    * list must be capped so that it is less than the cache size. Failure to do so can result in an
    * infinite loop in performAnalysisTask() because re-caching one AST structure can cause another
    * priority source's AST structure to be flushed.
    */
   static int _PRIORITY_ORDER_SIZE_DELTA = 4;
 
   /**
    * The set of analysis options controlling the behavior of this context.
@@ skipping 44 matching lines @@
    */
   IncrementalAnalysisCache _incrementalAnalysisCache;
 
   /**
    * Initialize a newly created analysis context.
    */
   AnalysisContextImpl() : super() {
     _resultRecorder = new AnalysisContextImpl_AnalysisTaskResultRecorder(this);
     _cache = new AnalysisCache(AnalysisOptionsImpl.DEFAULT_CACHE_SIZE, new AnalysisContextImpl_ContextRetentionPolicy(this));
   }
+
   void addSourceInfo(Source source, SourceEntry info) {
     _cache.put(source, info);
   }
+
   void applyChanges(ChangeSet changeSet) {
     if (changeSet.isEmpty) {
       return;
     }
     {
       List<Source> removedSources = new List<Source>.from(changeSet.removed3);
       for (SourceContainer container in changeSet.removedContainers) {
         addSourcesInContainer(removedSources, container);
       }
       bool addedDartSource = false;
       for (Source source in changeSet.added3) {
         if (sourceAvailable(source)) {
           addedDartSource = true;
         }
       }
       for (Source source in changeSet.changed3) {
         sourceChanged(source);
       }
       for (Source source in removedSources) {
         sourceRemoved(source);
       }
       if (addedDartSource) {
         for (MapEntry<Source, SourceEntry> mapEntry in _cache.entrySet()) {
           SourceEntry sourceEntry = mapEntry.getValue();
           if (!mapEntry.getKey().isInSystemLibrary && sourceEntry is DartEntry) {
-            DartEntryImpl dartCopy = ((sourceEntry as DartEntry)).writableCopy;
+            DartEntryImpl dartCopy = (sourceEntry as DartEntry).writableCopy;
             dartCopy.invalidateAllResolutionInformation();
             mapEntry.setValue(dartCopy);
           }
         }
       }
     }
   }
+
   String computeDocumentationComment(Element element) {
     if (element == null) {
       return null;
     }
     Source source = element.source;
     if (source == null) {
       return null;
     }
     CompilationUnit unit = parseCompilationUnit(source);
     if (unit == null) {
       return null;
     }
     NodeLocator locator = new NodeLocator.con1(element.nameOffset);
     ASTNode nameNode = locator.searchWithin(unit);
     while (nameNode != null) {
       if (nameNode is AnnotatedNode) {
-        Comment comment = ((nameNode as AnnotatedNode)).documentationComment;
+        Comment comment = (nameNode as AnnotatedNode).documentationComment;
         if (comment == null) {
           return null;
         }
         JavaStringBuilder builder = new JavaStringBuilder();
         List<Token> tokens = comment.tokens;
         for (int i = 0; i < tokens.length; i++) {
           if (i > 0) {
             builder.append('\n');
           }
           builder.append(tokens[i].lexeme);
         }
         return builder.toString();
       }
       nameNode = nameNode.parent;
     }
     return null;
   }
+
   List<AnalysisError> computeErrors(Source source) {
     bool enableHints = _options.hint;
     SourceEntry sourceEntry = getReadableSourceEntry(source);
     if (sourceEntry is DartEntry) {
       List<AnalysisError> errors = new List<AnalysisError>();
       DartEntry dartEntry = sourceEntry as DartEntry;
       ListUtilities.addAll(errors, getDartParseData(source, dartEntry, DartEntry.PARSE_ERRORS));
       dartEntry = getReadableDartEntry(source);
       if (identical(dartEntry.getValue(DartEntry.SOURCE_KIND), SourceKind.LIBRARY)) {
         ListUtilities.addAll(errors, getDartResolutionData(source, source, dartEntry, DartEntry.RESOLUTION_ERRORS));
@@ skipping 14 matching lines @@
       if (errors.isEmpty) {
         return AnalysisError.NO_ERRORS;
       }
       return new List.from(errors);
     } else if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry as HtmlEntry;
       return getHtmlResolutionData2(source, htmlEntry, HtmlEntry.RESOLUTION_ERRORS);
     }
     return AnalysisError.NO_ERRORS;
   }
+
   List<Source> computeExportedLibraries(Source source) => getDartParseData2(source, DartEntry.EXPORTED_LIBRARIES, Source.EMPTY_ARRAY);
+
   HtmlElement computeHtmlElement(Source source) => getHtmlResolutionData(source, HtmlEntry.ELEMENT, null);
+
   List<Source> computeImportedLibraries(Source source) => getDartParseData2(source, DartEntry.IMPORTED_LIBRARIES, Source.EMPTY_ARRAY);
+
   SourceKind computeKindOf(Source source) {
     SourceEntry sourceEntry = getReadableSourceEntry(source);
     if (sourceEntry == null) {
       return SourceKind.UNKNOWN;
     } else if (sourceEntry is DartEntry) {
       try {
         return getDartParseData(source, sourceEntry as DartEntry, DartEntry.SOURCE_KIND);
       } on AnalysisException catch (exception) {
         return SourceKind.UNKNOWN;
       }
     }
     return sourceEntry.kind;
   }
+
   LibraryElement computeLibraryElement(Source source) => getDartResolutionData2(source, source, DartEntry.ELEMENT, null);
+
   LineInfo computeLineInfo(Source source) {
     SourceEntry sourceEntry = getReadableSourceEntry(source);
     if (sourceEntry is HtmlEntry) {
       return getHtmlParseData(source, SourceEntry.LINE_INFO, null);
     } else if (sourceEntry is DartEntry) {
       return getDartParseData2(source, SourceEntry.LINE_INFO, null);
     }
     return null;
   }
+
   ResolvableCompilationUnit computeResolvableCompilationUnit(Source source) {
     while (true) {
       {
         DartEntry dartEntry = getReadableDartEntry(source);
         if (dartEntry == null) {
           throw new AnalysisException.con1("computeResolvableCompilationUnit for non-Dart: ${source.fullName}");
         }
         if (identical(dartEntry.getState(DartEntry.PARSED_UNIT), CacheState.ERROR)) {
           AnalysisException cause = dartEntry.exception;
           if (cause == null) {
             throw new AnalysisException.con1("Internal error: computeResolvableCompilationUnit could not parse ${source.fullName}");
           } else {
             throw new AnalysisException.con2("Internal error: computeResolvableCompilationUnit could not parse ${source.fullName}", cause);
           }
         }
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         CompilationUnit unit = dartCopy.resolvableCompilationUnit;
         if (unit != null) {
           _cache.put(source, dartCopy);
           return new ResolvableCompilationUnit(dartCopy.modificationTime, unit);
         }
       }
       cacheDartParseData(source, getReadableDartEntry(source), DartEntry.PARSED_UNIT);
     }
   }
+
   ResolvableHtmlUnit computeResolvableHtmlUnit(Source source) {
     HtmlEntry htmlEntry = getReadableHtmlEntry(source);
     if (htmlEntry == null) {
       throw new AnalysisException.con1("computeResolvableHtmlUnit invoked for non-HTML file: ${source.fullName}");
     }
     htmlEntry = cacheHtmlParseData(source, htmlEntry, HtmlEntry.PARSED_UNIT);
     HtmlUnit unit = htmlEntry.getValue(HtmlEntry.PARSED_UNIT);
     if (unit == null) {
       throw new AnalysisException.con1("Internal error: computeResolvableHtmlUnit could not parse ${source.fullName}");
     }
     return new ResolvableHtmlUnit(htmlEntry.modificationTime, unit);
   }
+
   AnalysisContext extractContext(SourceContainer container) => extractContextInto(container, AnalysisEngine.instance.createAnalysisContext() as InternalAnalysisContext);
+
   InternalAnalysisContext extractContextInto(SourceContainer container, InternalAnalysisContext newContext) {
     List<Source> sourcesToRemove = new List<Source>();
     {
       for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
         Source source = entry.getKey();
         if (container.contains(source)) {
           sourcesToRemove.add(source);
           newContext.addSourceInfo(source, entry.getValue().writableCopy);
         }
       }
     }
     return newContext;
   }
+
   AnalysisOptions get analysisOptions => _options;
+
   Element getElement(ElementLocation location) {
     try {
-      List<String> components = ((location as ElementLocationImpl)).components;
+      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;
     }
   }
+
   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));
     }
     return new AnalysisErrorInfoImpl(AnalysisError.NO_ERRORS, null);
   }
+
   HtmlElement getHtmlElement(Source source) {
     SourceEntry sourceEntry = getReadableSourceEntry(source);
     if (sourceEntry is HtmlEntry) {
-      return ((sourceEntry as HtmlEntry)).getValue(HtmlEntry.ELEMENT);
+      return (sourceEntry as HtmlEntry).getValue(HtmlEntry.ELEMENT);
     }
     return null;
   }
+
   List<Source> getHtmlFilesReferencing(Source source) {
     SourceKind sourceKind = getKindOf(source);
     if (sourceKind == null) {
       return Source.EMPTY_ARRAY;
     }
     {
       List<Source> htmlSources = new List<Source>();
       while (true) {
         if (sourceKind == SourceKind.LIBRARY) {
         } else if (sourceKind == SourceKind.PART) {
           List<Source> librarySources = getLibrariesContaining(source);
           for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
             SourceEntry sourceEntry = entry.getValue();
             if (identical(sourceEntry.kind, SourceKind.HTML)) {
-              List<Source> referencedLibraries = ((sourceEntry as HtmlEntry)).getValue(HtmlEntry.REFERENCED_LIBRARIES);
+              List<Source> referencedLibraries = (sourceEntry as HtmlEntry).getValue(HtmlEntry.REFERENCED_LIBRARIES);
               if (containsAny(referencedLibraries, librarySources)) {
                 htmlSources.add(entry.getKey());
               }
             }
           }
         }
         break;
       }
       if (htmlSources.isEmpty) {
         return Source.EMPTY_ARRAY;
       }
       return new List.from(htmlSources);
     }
   }
+
   List<Source> get htmlSources => getSources(SourceKind.HTML);
+
   SourceKind getKindOf(Source source) {
     SourceEntry sourceEntry = getReadableSourceEntry(source);
     if (sourceEntry == null) {
       return SourceKind.UNKNOWN;
     }
     return sourceEntry.kind;
   }
+
   List<Source> get launchableClientLibrarySources {
     List<Source> sources = new List<Source>();
     {
       for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
         Source source = entry.getKey();
         SourceEntry sourceEntry = entry.getValue();
         if (identical(sourceEntry.kind, SourceKind.LIBRARY) && !source.isInSystemLibrary) {
           sources.add(source);
         }
       }
     }
     return new List.from(sources);
   }
+
   List<Source> get launchableServerLibrarySources {
     List<Source> sources = new List<Source>();
     {
       for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
         Source source = entry.getKey();
         SourceEntry sourceEntry = entry.getValue();
         if (identical(sourceEntry.kind, SourceKind.LIBRARY) && !source.isInSystemLibrary) {
           sources.add(source);
         }
       }
     }
     return new List.from(sources);
   }
+
   List<Source> getLibrariesContaining(Source source) {
     {
       SourceEntry sourceEntry = _cache.get(source);
       if (sourceEntry == null || sourceEntry.kind != SourceKind.PART) {
         return <Source> [source];
       }
       List<Source> librarySources = new List<Source>();
       for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
         sourceEntry = entry.getValue();
         if (identical(sourceEntry.kind, SourceKind.LIBRARY)) {
-          if (contains(((sourceEntry as DartEntry)).getValue(DartEntry.INCLUDED_PARTS), source)) {
+          if (contains((sourceEntry as DartEntry).getValue(DartEntry.INCLUDED_PARTS), source)) {
             librarySources.add(entry.getKey());
           }
         }
       }
       if (librarySources.isEmpty) {
         return Source.EMPTY_ARRAY;
       }
       return new List.from(librarySources);
     }
   }
+
   List<Source> getLibrariesDependingOn(Source librarySource) {
     {
       List<Source> dependentLibraries = new List<Source>();
       for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
         SourceEntry sourceEntry = entry.getValue();
         if (identical(sourceEntry.kind, SourceKind.LIBRARY)) {
-          if (contains(((sourceEntry as DartEntry)).getValue(DartEntry.EXPORTED_LIBRARIES), librarySource)) {
+          if (contains((sourceEntry as DartEntry).getValue(DartEntry.EXPORTED_LIBRARIES), librarySource)) {
             dependentLibraries.add(entry.getKey());
           }
-          if (contains(((sourceEntry as DartEntry)).getValue(DartEntry.IMPORTED_LIBRARIES), librarySource)) {
+          if (contains((sourceEntry as DartEntry).getValue(DartEntry.IMPORTED_LIBRARIES), librarySource)) {
             dependentLibraries.add(entry.getKey());
           }
         }
       }
       if (dependentLibraries.isEmpty) {
         return Source.EMPTY_ARRAY;
       }
       return new List.from(dependentLibraries);
     }
   }
+
   LibraryElement getLibraryElement(Source source) {
     SourceEntry sourceEntry = getReadableSourceEntry(source);
     if (sourceEntry is DartEntry) {
-      return ((sourceEntry as DartEntry)).getValue(DartEntry.ELEMENT);
+      return (sourceEntry as DartEntry).getValue(DartEntry.ELEMENT);
     }
     return null;
   }
+
   List<Source> get librarySources => getSources(SourceKind.LIBRARY);
+
   LineInfo getLineInfo(Source source) {
     SourceEntry sourceEntry = getReadableSourceEntry(source);
     if (sourceEntry != null) {
       return sourceEntry.getValue(SourceEntry.LINE_INFO);
     }
     return null;
   }
+
   Namespace getPublicNamespace(LibraryElement library) {
     Source source = library.definingCompilationUnit.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.createPublicNamespace(library);
       {
         dartEntry = getReadableDartEntry(source);
         if (dartEntry == null) {
           AnalysisEngine.instance.logger.logError3(new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}"));
           return null;
         }
         if (identical(dartEntry.getValue(DartEntry.ELEMENT), library)) {
           DartEntryImpl dartCopy = getReadableDartEntry(source).writableCopy;
           dartCopy.setValue(DartEntry.PUBLIC_NAMESPACE, namespace);
           _cache.put(source, dartCopy);
         }
       }
     }
     return namespace;
   }
+
   Namespace getPublicNamespace2(Source source) {
     DartEntry dartEntry = getReadableDartEntry(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);
       {
         dartEntry = getReadableDartEntry(source);
         if (dartEntry == null) {
           throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
         }
         if (identical(dartEntry.getValue(DartEntry.ELEMENT), library)) {
           DartEntryImpl dartCopy = getReadableDartEntry(source).writableCopy;
           dartCopy.setValue(DartEntry.PUBLIC_NAMESPACE, namespace);
           _cache.put(source, dartCopy);
         }
       }
     }
     return namespace;
   }
+
   List<Source> get refactoringUnsafeSources {
     List<Source> sources = new List<Source>();
     {
       for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
         SourceEntry sourceEntry = entry.getValue();
         if (sourceEntry is DartEntry) {
-          if (!((sourceEntry as DartEntry)).isRefactoringSafe) {
+          if (!(sourceEntry as DartEntry).isRefactoringSafe) {
             sources.add(entry.getKey());
           }
         }
       }
     }
     return new List.from(sources);
   }
+
   CompilationUnit getResolvedCompilationUnit(Source unitSource, LibraryElement library) {
     if (library == null) {
       return null;
     }
     return getResolvedCompilationUnit2(unitSource, library.source);
   }
+
   CompilationUnit getResolvedCompilationUnit2(Source unitSource, Source librarySource) {
     SourceEntry sourceEntry = getReadableSourceEntry(unitSource);
     if (sourceEntry is DartEntry) {
-      return ((sourceEntry as DartEntry)).getValue2(DartEntry.RESOLVED_UNIT, librarySource);
+      return (sourceEntry as DartEntry).getValue2(DartEntry.RESOLVED_UNIT, librarySource);
     }
     return null;
   }
+
   SourceFactory get sourceFactory => _sourceFactory;
 
   /**
    * Return a list of the sources that would be processed by [performAnalysisTask]. This
    * method duplicates, and must therefore be kept in sync with, [getNextTaskAnalysisTask].
    * This method is intended to be used for testing purposes only.
    *
    * @return a list of the sources that would be processed by [performAnalysisTask]
    */
   List<Source> get sourcesNeedingProcessing {
     Set<Source> sources = new Set<Source>();
     {
       bool hintsEnabled = _options.hint;
       for (Source source in _priorityOrder) {
         getSourcesNeedingProcessing2(source, _cache.get(source), true, hintsEnabled, sources);
       }
       for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
         getSourcesNeedingProcessing2(entry.getKey(), entry.getValue(), false, hintsEnabled, sources);
       }
     }
     return new List<Source>.from(sources);
   }
+
   AnalysisContentStatistics get statistics {
     AnalysisContentStatisticsImpl statistics = new AnalysisContentStatisticsImpl();
     {
       for (MapEntry<Source, SourceEntry> mapEntry in _cache.entrySet()) {
         SourceEntry entry = mapEntry.getValue();
         if (entry is DartEntry) {
           Source source = mapEntry.getKey();
           DartEntry dartEntry = entry as DartEntry;
           SourceKind kind = dartEntry.getValue(DartEntry.SOURCE_KIND);
           statistics.putCacheItem(dartEntry, DartEntry.PARSE_ERRORS);
@@ skipping 13 matching lines @@
             statistics.putCacheItem2(dartEntry, librarySource, DartEntry.HINTS);
             statistics.putCacheItem2(dartEntry, librarySource, DartEntry.RESOLUTION_ERRORS);
             statistics.putCacheItem2(dartEntry, librarySource, DartEntry.RESOLVED_UNIT);
             statistics.putCacheItem2(dartEntry, librarySource, DartEntry.VERIFICATION_ERRORS);
           }
         }
       }
     }
     return statistics;
   }
+
   TimestampedData<CompilationUnit> internalResolveCompilationUnit(Source unitSource, LibraryElement libraryElement) {
     DartEntry dartEntry = getReadableDartEntry(unitSource);
     if (dartEntry == null) {
       throw new AnalysisException.con1("internalResolveCompilationUnit invoked for non-Dart file: ${unitSource.fullName}");
     }
     Source librarySource = libraryElement.source;
     dartEntry = cacheDartResolutionData(unitSource, librarySource, dartEntry, DartEntry.RESOLVED_UNIT);
     return new TimestampedData<CompilationUnit>(dartEntry.modificationTime, dartEntry.getValue2(DartEntry.RESOLVED_UNIT, librarySource));
   }
+
   bool isClientLibrary(Source librarySource) {
     SourceEntry sourceEntry = getReadableSourceEntry(librarySource);
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry as DartEntry;
       return dartEntry.getValue(DartEntry.IS_CLIENT) && dartEntry.getValue(DartEntry.IS_LAUNCHABLE);
     }
     return false;
   }
+
   bool isServerLibrary(Source librarySource) {
     SourceEntry sourceEntry = getReadableSourceEntry(librarySource);
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry as DartEntry;
       return !dartEntry.getValue(DartEntry.IS_CLIENT) && dartEntry.getValue(DartEntry.IS_LAUNCHABLE);
     }
     return false;
   }
+
   void mergeContext(AnalysisContext context) {
     if (context is InstrumentedAnalysisContextImpl) {
-      context = ((context as InstrumentedAnalysisContextImpl)).basis;
+      context = (context as InstrumentedAnalysisContextImpl).basis;
     }
     if (context is! AnalysisContextImpl) {
       return;
     }
     {
-      for (MapEntry<Source, SourceEntry> entry in ((context as AnalysisContextImpl))._cache.entrySet()) {
+      for (MapEntry<Source, SourceEntry> entry in (context as AnalysisContextImpl)._cache.entrySet()) {
         Source newSource = entry.getKey();
         SourceEntry existingEntry = getReadableSourceEntry(newSource);
         if (existingEntry == null) {
           _cache.put(newSource, entry.getValue().writableCopy);
         } else {
         }
       }
     }
   }
+
   CompilationUnit parseCompilationUnit(Source source) => getDartParseData2(source, DartEntry.PARSED_UNIT, null);
+
   HtmlUnit parseHtmlUnit(Source source) => getHtmlParseData(source, HtmlEntry.PARSED_UNIT, null);
+
   AnalysisResult performAnalysisTask() {
     int getStart = JavaSystem.currentTimeMillis();
     AnalysisTask task = nextTaskAnalysisTask;
     int getEnd = JavaSystem.currentTimeMillis();
     if (task == null) {
       return new AnalysisResult(getChangeNotices(true), getEnd - getStart, null, -1);
     }
     int performStart = JavaSystem.currentTimeMillis();
     try {
       task.perform(_resultRecorder);
     } on AnalysisException catch (exception) {
       if (exception.cause is! JavaIOException) {
         AnalysisEngine.instance.logger.logError2("Internal error while performing the task: ${task}", exception);
       }
     }
     int performEnd = JavaSystem.currentTimeMillis();
     return new AnalysisResult(getChangeNotices(false), getEnd - getStart, task.runtimeType.toString(), performEnd - performStart);
   }
+
   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();
         DartEntry dartEntry = getReadableDartEntry(librarySource);
         if (dartEntry != null) {
           DartEntryImpl dartCopy = dartEntry.writableCopy;
           recordElementData(dartCopy, library, htmlSource);
           _cache.put(librarySource, dartCopy);
         }
       }
     }
   }
+
   CompilationUnit resolveCompilationUnit(Source unitSource, LibraryElement library) {
     if (library == null) {
       return null;
     }
     return resolveCompilationUnit2(unitSource, library.source);
   }
+
   CompilationUnit resolveCompilationUnit2(Source unitSource, Source librarySource) => getDartResolutionData2(unitSource, librarySource, DartEntry.RESOLVED_UNIT, null);
+
   HtmlUnit resolveHtmlUnit(Source htmlSource) => parseHtmlUnit(htmlSource);
+
   void set analysisOptions(AnalysisOptions options) {
     {
       bool needsRecompute = this._options.dart2jsHint != options.dart2jsHint || (this._options.hint && !options.hint);
       int cacheSize = options.cacheSize;
       if (this._options.cacheSize != cacheSize) {
         this._options.cacheSize = cacheSize;
         _cache.maxCacheSize = cacheSize;
         int maxPriorityOrderSize = cacheSize - _PRIORITY_ORDER_SIZE_DELTA;
         if (_priorityOrder.length > maxPriorityOrderSize) {
           List<Source> newPriorityOrder = new List<Source>(maxPriorityOrderSize);
           JavaSystem.arraycopy(_priorityOrder, 0, newPriorityOrder, 0, maxPriorityOrderSize);
           _priorityOrder = newPriorityOrder;
         }
       }
       this._options.dart2jsHint = options.dart2jsHint;
       this._options.hint = options.hint;
       this._options.strictMode = options.strictMode;
       if (needsRecompute) {
         invalidateAllResolutionInformation();
       }
     }
   }
+
   void set analysisPriorityOrder(List<Source> sources) {
     {
       if (sources == null || sources.isEmpty) {
         _priorityOrder = Source.EMPTY_ARRAY;
       } else {
         while (sources.remove(null)) {
         }
         if (sources.isEmpty) {
           _priorityOrder = Source.EMPTY_ARRAY;
         }
         int count = Math.min(sources.length, _options.cacheSize - _PRIORITY_ORDER_SIZE_DELTA);
         _priorityOrder = new List<Source>(count);
         for (int i = 0; i < count; i++) {
           _priorityOrder[i] = sources[i];
         }
       }
     }
   }
+
   void setChangedContents(Source source, String contents, int offset, int oldLength, int newLength) {
     {
       String originalContents = _sourceFactory.setContents(source, contents);
       if (originalContents == null) {
         if (contents != null) {
           _incrementalAnalysisCache = IncrementalAnalysisCache.update(_incrementalAnalysisCache, source, originalContents, contents, offset, oldLength, newLength, getReadableSourceEntry(source));
           sourceChanged(source);
         }
       } else if (originalContents != contents) {
         _incrementalAnalysisCache = IncrementalAnalysisCache.update(_incrementalAnalysisCache, source, originalContents, contents, offset, oldLength, newLength, getReadableSourceEntry(source));
         sourceChanged(source);
       } else if (contents == null) {
         _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
       }
     }
   }
+
   void setContents(Source source, String contents) {
     {
       String originalContents = _sourceFactory.setContents(source, contents);
       if (originalContents == null) {
         if (contents != null) {
           sourceChanged(source);
         }
       } else if (originalContents != contents) {
         sourceChanged(source);
       }
       _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, 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 (_sourceFactory != null) {
         _sourceFactory.context = null;
       }
       factory.context = this;
       _sourceFactory = factory;
       invalidateAllResolutionInformation();
     }
   }
+
   Iterable<Source> sourcesToResolve(List<Source> changedSources) {
     List<Source> librarySources = new List<Source>();
     for (Source source in changedSources) {
       if (identical(computeKindOf(source), SourceKind.LIBRARY)) {
         librarySources.add(source);
       }
     }
     return librarySources;
   }
 
@@ skipping 479 matching lines @@
    *
    * @param source the source to be checked
    * @param sourceEntry the cache entry associated with the source
    * @param isPriority `true` if the source is a priority source
    * @param hintsEnabled `true` if hints are currently enabled
    * @return the next task that needs to be performed for the given source
    */
   AnalysisTask getNextTaskAnalysisTask2(Source source, SourceEntry sourceEntry, bool isPriority, bool hintsEnabled) {
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry as DartEntry;
+      if (!source.exists()) {
+        DartEntryImpl dartCopy = dartEntry.writableCopy;
+        dartCopy.recordParseError();
+        dartCopy.exception = new AnalysisException.con1("Source does not exist");
+        _cache.put(source, dartCopy);
+        return null;
+      }
       CacheState parseErrorsState = dartEntry.getState(DartEntry.PARSE_ERRORS);
       if (identical(parseErrorsState, CacheState.INVALID) || (isPriority && identical(parseErrorsState, CacheState.FLUSHED))) {
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         dartCopy.setState(DartEntry.PARSE_ERRORS, CacheState.IN_PROCESS);
         _cache.put(source, dartCopy);
         return new ParseDartTask(this, source);
       }
       if (isPriority && parseErrorsState != CacheState.ERROR) {
         CompilationUnit parseUnit = dartEntry.anyParsedCompilationUnit;
         if (parseUnit == null) {
           DartEntryImpl dartCopy = dartEntry.writableCopy;
           dartCopy.setState(DartEntry.PARSED_UNIT, CacheState.IN_PROCESS);
           _cache.put(source, dartCopy);
           return new ParseDartTask(this, source);
         }
       }
       for (Source librarySource in getLibrariesContaining(source)) {
         SourceEntry libraryEntry = _cache.get(librarySource);
         if (libraryEntry is DartEntry) {
           CacheState elementState = libraryEntry.getState(DartEntry.ELEMENT);
           if (identical(elementState, CacheState.INVALID) || (isPriority && identical(elementState, CacheState.FLUSHED))) {
-            DartEntryImpl libraryCopy = ((libraryEntry as DartEntry)).writableCopy;
+            DartEntryImpl libraryCopy = (libraryEntry as DartEntry).writableCopy;
             libraryCopy.setState(DartEntry.ELEMENT, CacheState.IN_PROCESS);
             _cache.put(librarySource, libraryCopy);
             return new ResolveDartLibraryTask(this, source, librarySource);
           }
           CacheState resolvedUnitState = dartEntry.getState2(DartEntry.RESOLVED_UNIT, librarySource);
           if (identical(resolvedUnitState, CacheState.INVALID) || (isPriority && identical(resolvedUnitState, CacheState.FLUSHED))) {
             DartEntryImpl dartCopy = dartEntry.writableCopy;
             dartCopy.setState2(DartEntry.RESOLVED_UNIT, librarySource, CacheState.IN_PROCESS);
             _cache.put(source, dartCopy);
             return new ResolveDartLibraryTask(this, source, librarySource);
@@ skipping 17 matching lines @@
                 dartCopy.setState2(DartEntry.HINTS, librarySource, CacheState.IN_PROCESS);
                 _cache.put(source, dartCopy);
                 return new GenerateDartHintsTask(this, libraryElement);
               }
             }
           }
         }
       }
     } else if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry as HtmlEntry;
+      if (!source.exists()) {
+        HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
+        htmlCopy.recordParseError();
+        htmlCopy.exception = new AnalysisException.con1("Source does not exist");
+        _cache.put(source, htmlCopy);
+        return null;
+      }
       CacheState parsedUnitState = htmlEntry.getState(HtmlEntry.PARSED_UNIT);
       if (identical(parsedUnitState, CacheState.INVALID) || (isPriority && identical(parsedUnitState, CacheState.FLUSHED))) {
         HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
         htmlCopy.setState(HtmlEntry.PARSED_UNIT, CacheState.IN_PROCESS);
         _cache.put(source, htmlCopy);
         return new ParseHtmlTask(this, source);
       }
       CacheState elementState = htmlEntry.getState(HtmlEntry.ELEMENT);
       if (identical(elementState, CacheState.INVALID) || (isPriority && identical(elementState, CacheState.FLUSHED))) {
         HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
@@ skipping 183 matching lines @@
 
   /**
    * Invalidate all of the resolution results computed by this context.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    */
   void invalidateAllResolutionInformation() {
     for (MapEntry<Source, SourceEntry> mapEntry in _cache.entrySet()) {
       SourceEntry sourceEntry = mapEntry.getValue();
       if (sourceEntry is HtmlEntry) {
-        HtmlEntryImpl htmlCopy = ((sourceEntry as HtmlEntry)).writableCopy;
+        HtmlEntryImpl htmlCopy = (sourceEntry as HtmlEntry).writableCopy;
         htmlCopy.invalidateAllResolutionInformation();
         mapEntry.setValue(htmlCopy);
       } else if (sourceEntry is DartEntry) {
-        DartEntryImpl dartCopy = ((sourceEntry as DartEntry)).writableCopy;
+        DartEntryImpl dartCopy = (sourceEntry as DartEntry).writableCopy;
         dartCopy.invalidateAllResolutionInformation();
         mapEntry.setValue(dartCopy);
       }
     }
   }
 
   /**
    * 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].
    *
    * @param librarySource the source of the library being invalidated
    */
   void invalidateLibraryResolution(Source librarySource) {
     DartEntry libraryEntry = getReadableDartEntry(librarySource);
     if (libraryEntry != null) {
       List<Source> includedParts = libraryEntry.getValue(DartEntry.INCLUDED_PARTS);
       DartEntryImpl libraryCopy = libraryEntry.writableCopy;
       libraryCopy.invalidateAllResolutionInformation();
       libraryCopy.setState(DartEntry.INCLUDED_PARTS, CacheState.INVALID);
       _cache.put(librarySource, libraryCopy);
       for (Source partSource in includedParts) {
         SourceEntry partEntry = _cache.get(partSource);
         if (partEntry is DartEntry) {
-          DartEntryImpl partCopy = ((partEntry as DartEntry)).writableCopy;
+          DartEntryImpl partCopy = (partEntry as DartEntry).writableCopy;
           partCopy.invalidateAllResolutionInformation();
           _cache.put(partSource, partCopy);
         }
       }
     }
   }
 
   /**
    * Return `true` if this library is, or depends on, dart:html.
    *
@@ skipping 118 matching lines @@
     Map<Source, TimestampedData<List<AnalysisError>>> hintMap = task.hintMap;
     if (hintMap == null) {
       {
         SourceEntry sourceEntry = _cache.get(librarySource);
         if (sourceEntry is! DartEntry) {
           throw new AnalysisException.con1("Internal error: attempting to generate hints for non-Dart file as a Dart file: ${librarySource.fullName}");
         }
         if (thrownException == null) {
           thrownException = new AnalysisException.con1("GenerateDartHintsTask returned a null hint map without throwing an exception: ${librarySource.fullName}");
         }
-        DartEntryImpl dartCopy = ((sourceEntry as DartEntry)).writableCopy;
+        DartEntryImpl dartCopy = (sourceEntry as DartEntry).writableCopy;
         dartCopy.setState2(DartEntry.HINTS, librarySource, CacheState.ERROR);
         dartCopy.exception = thrownException;
         _cache.put(librarySource, dartCopy);
       }
       throw thrownException;
     }
     for (MapEntry<Source, TimestampedData<List<AnalysisError>>> entry in getMapEntrySet(hintMap)) {
       Source unitSource = entry.getKey();
       TimestampedData<List<AnalysisError>> results = entry.getValue();
       {
@@ skipping 159 matching lines @@
       int sourceTime = source.modificationStamp;
       int resultTime = task.modificationTime;
       if (sourceTime == resultTime) {
         if (htmlEntry.modificationTime != sourceTime) {
           sourceChanged(source);
           htmlEntry = getReadableHtmlEntry(source);
           if (htmlEntry == null) {
             throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
           }
         }
-        HtmlEntryImpl htmlCopy = ((sourceEntry as HtmlEntry)).writableCopy;
+        HtmlEntryImpl htmlCopy = (sourceEntry as HtmlEntry).writableCopy;
         if (thrownException == null) {
           LineInfo lineInfo = task.lineInfo;
           HtmlUnit unit = task.htmlUnit;
           htmlCopy.setValue(SourceEntry.LINE_INFO, lineInfo);
           htmlCopy.setValue(HtmlEntry.PARSED_UNIT, unit);
           htmlCopy.setValue(HtmlEntry.REFERENCED_LIBRARIES, task.referencedLibraries);
           ChangeNoticeImpl notice = getNotice(source);
           notice.setErrors(htmlEntry.allErrors, lineInfo);
         } else {
-          htmlCopy.setState(SourceEntry.LINE_INFO, CacheState.ERROR);
-          htmlCopy.setState(HtmlEntry.PARSED_UNIT, CacheState.ERROR);
-          htmlCopy.setState(HtmlEntry.REFERENCED_LIBRARIES, CacheState.ERROR);
+          htmlCopy.recordParseError();
         }
         htmlCopy.exception = thrownException;
         _cache.put(source, htmlCopy);
         htmlEntry = htmlCopy;
       } else {
-        HtmlEntryImpl htmlCopy = ((sourceEntry as HtmlEntry)).writableCopy;
+        HtmlEntryImpl htmlCopy = (sourceEntry as HtmlEntry).writableCopy;
         if (thrownException == null || resultTime >= 0) {
           if (identical(htmlCopy.getState(SourceEntry.LINE_INFO), CacheState.IN_PROCESS)) {
             htmlCopy.setState(SourceEntry.LINE_INFO, CacheState.INVALID);
           }
           if (identical(htmlCopy.getState(HtmlEntry.PARSED_UNIT), CacheState.IN_PROCESS)) {
             htmlCopy.setState(HtmlEntry.PARSED_UNIT, CacheState.INVALID);
           }
           if (identical(htmlCopy.getState(HtmlEntry.REFERENCED_LIBRARIES), CacheState.IN_PROCESS)) {
             htmlCopy.setState(HtmlEntry.REFERENCED_LIBRARIES, CacheState.INVALID);
           }
@@ skipping 263 matching lines @@
   }
 
   /**
    * <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 = _cache.get(source);
     if (sourceEntry is HtmlEntry) {
-      HtmlEntryImpl htmlCopy = ((sourceEntry as HtmlEntry)).writableCopy;
+      HtmlEntryImpl htmlCopy = (sourceEntry as HtmlEntry).writableCopy;
       htmlCopy.modificationTime = source.modificationStamp;
       htmlCopy.invalidateAllInformation();
       _cache.put(source, htmlCopy);
     } else if (sourceEntry is DartEntry) {
       List<Source> containingLibraries = getLibrariesContaining(source);
       Set<Source> librariesToInvalidate = new Set<Source>();
       for (Source containingLibrary in containingLibraries) {
         javaSetAdd(librariesToInvalidate, containingLibrary);
         for (Source dependentLibrary in getLibrariesDependingOn(containingLibrary)) {
           javaSetAdd(librariesToInvalidate, dependentLibrary);
         }
       }
       for (Source library in librariesToInvalidate) {
         invalidateLibraryResolution(library);
       }
-      DartEntryImpl dartCopy = ((sourceEntry as DartEntry)).writableCopy;
+      DartEntryImpl dartCopy = (sourceEntry as DartEntry).writableCopy;
       dartCopy.modificationTime = source.modificationStamp;
       dartCopy.invalidateAllInformation();
       _cache.put(source, dartCopy);
     }
   }
 
   /**
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source that has been deleted
    */
   void sourceRemoved(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry is DartEntry) {
       Set<Source> libraries = new Set<Source>();
       for (Source librarySource in getLibrariesContaining(source)) {
         javaSetAdd(libraries, librarySource);
         for (Source dependentLibrary in getLibrariesDependingOn(librarySource)) {
           javaSetAdd(libraries, dependentLibrary);
         }
       }
       for (Source librarySource in libraries) {
         invalidateLibraryResolution(librarySource);
       }
     }
     _cache.remove(source);
   }
 }
+
 /**
  * Instances of the class `AnalysisTaskResultRecorder` are used by an analysis context to
  * record the results of a task.
  */
 class AnalysisContextImpl_AnalysisTaskResultRecorder implements AnalysisTaskVisitor<SourceEntry> {
   final AnalysisContextImpl AnalysisContextImpl_this;
+
   AnalysisContextImpl_AnalysisTaskResultRecorder(this.AnalysisContextImpl_this);
+
   SourceEntry visitGenerateDartErrorsTask(GenerateDartErrorsTask task) => AnalysisContextImpl_this.recordGenerateDartErrorsTask(task);
+
   SourceEntry visitGenerateDartHintsTask(GenerateDartHintsTask task) => AnalysisContextImpl_this.recordGenerateDartHintsTask(task);
+
   SourceEntry visitIncrementalAnalysisTask(IncrementalAnalysisTask task) => AnalysisContextImpl_this.recordIncrementalAnalysisTaskResults(task);
+
   DartEntry visitParseDartTask(ParseDartTask task) => AnalysisContextImpl_this.recordParseDartTaskResults(task);
+
   HtmlEntry visitParseHtmlTask(ParseHtmlTask task) => AnalysisContextImpl_this.recordParseHtmlTaskResults(task);
+
   DartEntry visitResolveDartLibraryTask(ResolveDartLibraryTask task) => AnalysisContextImpl_this.recordResolveDartLibraryTaskResults(task);
+
   SourceEntry visitResolveDartUnitTask(ResolveDartUnitTask task) => AnalysisContextImpl_this.recordResolveDartUnitTaskResults(task);
+
   SourceEntry visitResolveHtmlTask(ResolveHtmlTask task) => AnalysisContextImpl_this.recordResolveHtmlTaskResults(task);
 }
+
 class AnalysisContextImpl_ContextRetentionPolicy implements CacheRetentionPolicy {
   final AnalysisContextImpl AnalysisContextImpl_this;
+
   AnalysisContextImpl_ContextRetentionPolicy(this.AnalysisContextImpl_this);
+
   RetentionPriority getAstPriority(Source source, SourceEntry sourceEntry) {
     for (Source prioritySource in AnalysisContextImpl_this._priorityOrder) {
       if (source == prioritySource) {
         return RetentionPriority.HIGH;
       }
     }
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry as DartEntry;
       if (astIsNeeded(dartEntry)) {
         return RetentionPriority.MEDIUM;
       }
     }
     return RetentionPriority.LOW;
   }
+
   bool astIsNeeded(DartEntry dartEntry) => dartEntry.hasInvalidData(DartEntry.HINTS) || dartEntry.hasInvalidData(DartEntry.VERIFICATION_ERRORS) || dartEntry.hasInvalidData(DartEntry.RESOLUTION_ERRORS);
 }
+
 /**
  * Instances of the class `AnalysisErrorInfoImpl` represent the analysis errors and line info
  * associated with a source.
  */
 class AnalysisErrorInfoImpl implements AnalysisErrorInfo {
-
   /**
    * The analysis errors associated with a source, or `null` if there are no errors.
    */
   List<AnalysisError> _errors;
 
   /**
    * The line information associated with the errors, or `null` if there are no errors.
    */
   LineInfo _lineInfo;
 
@@ skipping 16 matching lines @@
   List<AnalysisError> get errors => _errors;
 
   /**
    * Return the line information associated with the errors, or `null` if there were no
    * errors.
    *
    * @return the line information associated with the errors
    */
   LineInfo get lineInfo => _lineInfo;
 }
+
 /**
  * Instances of the class `AnalysisOptions` represent a set of analysis options used to
  * control the behavior of an analysis context.
  */
 class AnalysisOptionsImpl implements AnalysisOptions {
-
   /**
    * The maximum number of sources for which data should be kept in the cache.
    */
   static int DEFAULT_CACHE_SIZE = 64;
 
   /**
    * The maximum number of sources for which AST structures should be kept in the cache.
    */
   int _cacheSize = DEFAULT_CACHE_SIZE;
 
@@ skipping 24 matching lines @@
    * given set of analysis options.
    *
    * @param options the analysis options whose values are being copied
    */
   AnalysisOptionsImpl.con1(AnalysisOptions options) {
     _cacheSize = options.cacheSize;
     _dart2jsHint = options.dart2jsHint;
     _hint = options.hint;
     _strictMode = options.strictMode;
   }
+
   int get cacheSize => _cacheSize;
+
   bool get dart2jsHint => _dart2jsHint;
+
   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;
 
@@ skipping 30 matching lines @@
   /**
    * 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;
   }
 }
+
 /**
  * Instances of the class `ChangeNoticeImpl` represent a change to the analysis results
  * associated with a given source.
  *
  * @coverage dart.engine
  */
 class ChangeNoticeImpl implements ChangeNotice {
-
   /**
    * The source for which the result is being reported.
    */
   Source _source;
 
   /**
    * The fully resolved AST that changed as a result of the analysis, or `null` if the AST was
    * not changed.
    */
   CompilationUnit _compilationUnit;
@@ skipping 70 matching lines @@
    * @param errors the errors that changed as a result of the analysis
    * @param lineInfo the line information associated with the source
    */
   void setErrors(List<AnalysisError> errors, LineInfo lineInfo) {
     this._errors = errors;
     this._lineInfo = lineInfo;
     if (lineInfo == null) {
       AnalysisEngine.instance.logger.logError2("No line info: ${_source}", new JavaException());
     }
   }
+
   String toString() => "Changes for ${_source.fullName}";
 }
+
 /**
  * Instances of the class `DelegatingAnalysisContextImpl` extend [AnalysisContextImpl
  ] to delegate sources to the appropriate analysis context. For instance, if the
  * source is in a system library then the analysis context from the [DartSdk] is used.
  *
  * @coverage dart.engine
  */
 class DelegatingAnalysisContextImpl extends AnalysisContextImpl {
-
   /**
    * This references the [InternalAnalysisContext] held onto by the [DartSdk] which is
    * used (instead of this [AnalysisContext]) for SDK sources. This field is set when
    * #setSourceFactory(SourceFactory) is called, and references the analysis context in the
    * [DartUriResolver] in the [SourceFactory], this analysis context assumes that there
    * will be such a resolver.
    */
   InternalAnalysisContext _sdkAnalysisContext;
+
   void addSourceInfo(Source source, SourceEntry info) {
     if (source.isInSystemLibrary) {
       _sdkAnalysisContext.addSourceInfo(source, info);
     } else {
       super.addSourceInfo(source, info);
     }
   }
+
   List<AnalysisError> computeErrors(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.computeErrors(source);
     } else {
       return super.computeErrors(source);
     }
   }
+
   List<Source> computeExportedLibraries(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.computeExportedLibraries(source);
     } else {
       return super.computeExportedLibraries(source);
     }
   }
+
   HtmlElement computeHtmlElement(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.computeHtmlElement(source);
     } else {
       return super.computeHtmlElement(source);
     }
   }
+
   List<Source> computeImportedLibraries(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.computeImportedLibraries(source);
     } else {
       return super.computeImportedLibraries(source);
     }
   }
+
   SourceKind computeKindOf(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.computeKindOf(source);
     } else {
       return super.computeKindOf(source);
     }
   }
+
   LibraryElement computeLibraryElement(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.computeLibraryElement(source);
     } else {
       return super.computeLibraryElement(source);
     }
   }
+
   LineInfo computeLineInfo(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.computeLineInfo(source);
     } else {
       return super.computeLineInfo(source);
     }
   }
+
   ResolvableCompilationUnit computeResolvableCompilationUnit(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.computeResolvableCompilationUnit(source);
     } else {
       return super.computeResolvableCompilationUnit(source);
     }
   }
+
   AnalysisErrorInfo getErrors(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.getErrors(source);
     } else {
       return super.getErrors(source);
     }
   }
+
   HtmlElement getHtmlElement(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.getHtmlElement(source);
     } else {
       return super.getHtmlElement(source);
     }
   }
+
   List<Source> getHtmlFilesReferencing(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.getHtmlFilesReferencing(source);
     } else {
       return super.getHtmlFilesReferencing(source);
     }
   }
+
   SourceKind getKindOf(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.getKindOf(source);
     } else {
       return super.getKindOf(source);
     }
   }
+
   List<Source> getLibrariesContaining(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.getLibrariesContaining(source);
     } else {
       return super.getLibrariesContaining(source);
     }
   }
+
   List<Source> getLibrariesDependingOn(Source librarySource) {
     if (librarySource.isInSystemLibrary) {
       return _sdkAnalysisContext.getLibrariesDependingOn(librarySource);
     } else {
       return super.getLibrariesDependingOn(librarySource);
     }
   }
+
   LibraryElement getLibraryElement(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.getLibraryElement(source);
     } else {
       return super.getLibraryElement(source);
     }
   }
+
   List<Source> get librarySources => ArrayUtils.addAll(super.librarySources, _sdkAnalysisContext.librarySources);
+
   LineInfo getLineInfo(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.getLineInfo(source);
     } else {
       return super.getLineInfo(source);
     }
   }
+
   Namespace getPublicNamespace(LibraryElement library) {
     Source source = library.source;
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.getPublicNamespace(library);
     } else {
       return super.getPublicNamespace(library);
     }
   }
+
   Namespace getPublicNamespace2(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.getPublicNamespace2(source);
     } else {
       return super.getPublicNamespace2(source);
     }
   }
+
   CompilationUnit getResolvedCompilationUnit(Source unitSource, LibraryElement library) {
     if (unitSource.isInSystemLibrary) {
       return _sdkAnalysisContext.getResolvedCompilationUnit(unitSource, library);
     } else {
       return super.getResolvedCompilationUnit(unitSource, library);
     }
   }
+
   CompilationUnit getResolvedCompilationUnit2(Source unitSource, Source librarySource) {
     if (unitSource.isInSystemLibrary) {
       return _sdkAnalysisContext.getResolvedCompilationUnit2(unitSource, librarySource);
     } else {
       return super.getResolvedCompilationUnit2(unitSource, librarySource);
     }
   }
+
   bool isClientLibrary(Source librarySource) {
     if (librarySource.isInSystemLibrary) {
       return _sdkAnalysisContext.isClientLibrary(librarySource);
     } else {
       return super.isClientLibrary(librarySource);
     }
   }
+
   bool isServerLibrary(Source librarySource) {
     if (librarySource.isInSystemLibrary) {
       return _sdkAnalysisContext.isServerLibrary(librarySource);
     } else {
       return super.isServerLibrary(librarySource);
     }
   }
+
   CompilationUnit parseCompilationUnit(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.parseCompilationUnit(source);
     } else {
       return super.parseCompilationUnit(source);
     }
   }
+
   HtmlUnit parseHtmlUnit(Source source) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.parseHtmlUnit(source);
     } else {
       return super.parseHtmlUnit(source);
     }
   }
+
   void recordLibraryElements(Map<Source, LibraryElement> elementMap) {
     if (elementMap.isEmpty) {
       return;
     }
     Source source = new JavaIterator(elementMap.keys.toSet()).next();
     if (source.isInSystemLibrary) {
       _sdkAnalysisContext.recordLibraryElements(elementMap);
     } else {
       super.recordLibraryElements(elementMap);
     }
   }
+
   CompilationUnit resolveCompilationUnit(Source source, LibraryElement library) {
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.resolveCompilationUnit(source, library);
     } else {
       return super.resolveCompilationUnit(source, library);
     }
   }
+
   CompilationUnit resolveCompilationUnit2(Source unitSource, Source librarySource) {
     if (unitSource.isInSystemLibrary) {
       return _sdkAnalysisContext.resolveCompilationUnit2(unitSource, librarySource);
     } else {
       return super.resolveCompilationUnit2(unitSource, librarySource);
     }
   }
+
   HtmlUnit resolveHtmlUnit(Source unitSource) {
     if (unitSource.isInSystemLibrary) {
       return _sdkAnalysisContext.resolveHtmlUnit(unitSource);
     } else {
       return super.resolveHtmlUnit(unitSource);
     }
   }
+
   void setChangedContents(Source source, String contents, int offset, int oldLength, int newLength) {
     if (source.isInSystemLibrary) {
       _sdkAnalysisContext.setChangedContents(source, contents, offset, oldLength, newLength);
     } else {
       super.setChangedContents(source, contents, offset, oldLength, newLength);
     }
   }
+
   void setContents(Source source, String contents) {
     if (source.isInSystemLibrary) {
       _sdkAnalysisContext.setContents(source, contents);
     } else {
       super.setContents(source, contents);
     }
   }
+
   void set sourceFactory(SourceFactory factory) {
     super.sourceFactory = factory;
     DartSdk sdk = factory.dartSdk;
     if (sdk != null) {
       _sdkAnalysisContext = sdk.context as InternalAnalysisContext;
       if (_sdkAnalysisContext is DelegatingAnalysisContextImpl) {
         _sdkAnalysisContext = null;
         throw new IllegalStateException("The context provided by an SDK cannot itself be a delegating analysis context");
       }
     } else {
       throw new IllegalStateException("SourceFactorys provided to DelegatingAnalysisContextImpls must have a DartSdk associated with the provided SourceFactory.");
     }
   }
 }
+
 /**
  * Instances of the class `IncrementalAnalysisCache` hold information used to perform
  * incremental analysis.
  *
  * @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
    */
   static IncrementalAnalysisCache cacheResult(IncrementalAnalysisCache cache, CompilationUnit unit) {
     if (cache != null && unit != null) {
@@ skipping 81 matching lines @@
    *         cannot be cached for the next incremental analysis
    */
   static IncrementalAnalysisCache verifyStructure(IncrementalAnalysisCache cache, Source source, CompilationUnit unit) {
     if (cache != null && unit != null && cache.source == source) {
       if (!ASTComparator.equals3(cache.resolvedUnit, unit)) {
         return null;
       }
     }
     return cache;
   }
+
   Source librarySource;
+
   Source source;
+
   String oldContents;
+
   CompilationUnit resolvedUnit;
+
   String newContents;
+
   int offset = 0;
+
   int oldLength = 0;
+
   int newLength = 0;
+
   IncrementalAnalysisCache(Source librarySource, Source source, CompilationUnit resolvedUnit, String oldContents, String newContents, int offset, int oldLength, int newLength) {
     this.librarySource = librarySource;
     this.source = source;
     this.resolvedUnit = resolvedUnit;
     this.oldContents = oldContents;
     this.newContents = newContents;
     this.offset = offset;
     this.oldLength = oldLength;
     this.newLength = newLength;
   }
 
   /**
    * Determine if the cache contains source changes that need to be analyzed
    *
    * @return `true` if the cache contains changes to be analyzed, else `false`
    */
-  bool hasWork() => oldLength > 0 && newLength > 0;
+  bool hasWork() => oldLength > 0 || newLength > 0;
 }
+
 /**
  * Instances of the class `InstrumentedAnalysisContextImpl` implement an
  * [AnalysisContext] by recording instrumentation data and delegating to
  * another analysis context to do the non-instrumentation work.
  *
  * @coverage dart.engine
  */
 class InstrumentedAnalysisContextImpl implements InternalAnalysisContext {
-
   /**
    * Record an exception that was thrown during analysis.
    *
    * @param instrumentation the instrumentation builder being used to record the exception
    * @param exception the exception being reported
    */
   static void recordAnalysisException(InstrumentationBuilder instrumentation, AnalysisException exception) {
     instrumentation.record(exception);
   }
 
@@ skipping 15 matching lines @@
 
   /**
    * 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) {
     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);
     } finally {
       instrumentation.log();
     }
   }
+
   String computeDocumentationComment(Element element) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeDocumentationComment");
     try {
       instrumentation.metric3("contextId", _contextId);
       return basis.computeDocumentationComment(element);
     } finally {
       instrumentation.log();
     }
   }
+
   List<AnalysisError> computeErrors(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeErrors");
     try {
       instrumentation.metric3("contextId", _contextId);
       List<AnalysisError> errors = basis.computeErrors(source);
       instrumentation.metric2("Errors-count", errors.length);
       return errors;
     } finally {
       instrumentation.log();
     }
   }
+
   List<Source> computeExportedLibraries(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeExportedLibraries");
     try {
       instrumentation.metric3("contextId", _contextId);
       return basis.computeExportedLibraries(source);
     } finally {
       instrumentation.log();
     }
   }
+
   HtmlElement computeHtmlElement(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeHtmlElement");
     try {
       instrumentation.metric3("contextId", _contextId);
       return basis.computeHtmlElement(source);
     } on AnalysisException catch (e) {
       recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
+
   List<Source> computeImportedLibraries(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeImportedLibraries");
     try {
       instrumentation.metric3("contextId", _contextId);
       return basis.computeImportedLibraries(source);
     } finally {
       instrumentation.log();
     }
   }
+
   SourceKind computeKindOf(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeKindOf");
     try {
       instrumentation.metric3("contextId", _contextId);
       return basis.computeKindOf(source);
     } finally {
       instrumentation.log();
     }
   }
+
   LibraryElement computeLibraryElement(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeLibraryElement");
     try {
       instrumentation.metric3("contextId", _contextId);
       return basis.computeLibraryElement(source);
     } on AnalysisException catch (e) {
       recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
+
   LineInfo computeLineInfo(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeLineInfo");
     try {
       instrumentation.metric3("contextId", _contextId);
       return basis.computeLineInfo(source);
     } on AnalysisException catch (e) {
       recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
+
   ResolvableCompilationUnit computeResolvableCompilationUnit(Source source) => basis.computeResolvableCompilationUnit(source);
+
   ResolvableHtmlUnit computeResolvableHtmlUnit(Source source) => basis.computeResolvableHtmlUnit(source);
+
   AnalysisContext extractContext(SourceContainer container) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-extractContext");
     try {
       instrumentation.metric3("contextId", _contextId);
       InstrumentedAnalysisContextImpl newContext = new InstrumentedAnalysisContextImpl();
       basis.extractContextInto(container, newContext.basis);
       return newContext;
     } finally {
       instrumentation.log();
     }
   }
+
   InternalAnalysisContext extractContextInto(SourceContainer container, InternalAnalysisContext newContext) => basis.extractContextInto(container, newContext);
+
   AnalysisOptions get analysisOptions {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getAnalysisOptions");
     try {
       instrumentation.metric3("contextId", _contextId);
       return basis.analysisOptions;
     } finally {
       instrumentation.log();
     }
   }
+
   Element getElement(ElementLocation location) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getElement");
     try {
       instrumentation.metric3("contextId", _contextId);
       return basis.getElement(location);
     } finally {
       instrumentation.log();
     }
   }
+
   AnalysisErrorInfo getErrors(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getErrors");
     try {
       instrumentation.metric3("contextId", _contextId);
       AnalysisErrorInfo ret = basis.getErrors(source);
       if (ret != null) {
         instrumentation.metric2("Errors-count", ret.errors.length);
       }
       return ret;
     } finally {
       instrumentation.log();
     }
   }
+
   HtmlElement getHtmlElement(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getHtmlElement");
     try {
       instrumentation.metric3("contextId", _contextId);
       return basis.getHtmlElement(source);
     } finally {
       instrumentation.log();
     }
   }
+
   List<Source> getHtmlFilesReferencing(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getHtmlFilesReferencing");
     try {
       instrumentation.metric3("contextId", _contextId);
       List<Source> ret = basis.getHtmlFilesReferencing(source);
       if (ret != null) {
         instrumentation.metric2("Source-count", ret.length);
       }
       return ret;
     } finally {
       instrumentation.log();
     }
   }
+
   List<Source> get htmlSources {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getHtmlSources");
     try {
       instrumentation.metric3("contextId", _contextId);
       List<Source> ret = basis.htmlSources;
       if (ret != null) {
         instrumentation.metric2("Source-count", ret.length);
       }
       return ret;
     } finally {
       instrumentation.log();
     }
   }
+
   SourceKind getKindOf(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getKindOf");
     try {
       instrumentation.metric3("contextId", _contextId);
       return basis.getKindOf(source);
     } finally {
       instrumentation.log();
     }
   }
+
   List<Source> get launchableClientLibrarySources {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getLaunchableClientLibrarySources");
     try {
       instrumentation.metric3("contextId", _contextId);
       List<Source> ret = basis.launchableClientLibrarySources;
       if (ret != null) {
         instrumentation.metric2("Source-count", ret.length);
       }
       return ret;
     } finally {
       instrumentation.log();
     }
   }
+
   List<Source> get launchableServerLibrarySources {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getLaunchableServerLibrarySources");
     try {
       instrumentation.metric3("contextId", _contextId);
       List<Source> ret = basis.launchableServerLibrarySources;
       if (ret != null) {
         instrumentation.metric2("Source-count", ret.length);
       }
       return ret;
     } finally {
       instrumentation.log();
     }
   }
+
   List<Source> getLibrariesContaining(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getLibrariesContaining");
     try {
       instrumentation.metric3("contextId", _contextId);
       List<Source> ret = basis.getLibrariesContaining(source);
       if (ret != null) {
         instrumentation.metric2("Source-count", ret.length);
       }
       return ret;
     } finally {
       instrumentation.log2(2);
     }
   }
+
   List<Source> getLibrariesDependingOn(Source librarySource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getLibrariesDependingOn");
     try {
       instrumentation.metric3("contextId", _contextId);
       List<Source> ret = basis.getLibrariesDependingOn(librarySource);
       if (ret != null) {
         instrumentation.metric2("Source-count", ret.length);
       }
       return ret;
     } finally {
       instrumentation.log();
     }
   }
+
   LibraryElement getLibraryElement(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getLibraryElement");
     try {
       instrumentation.metric3("contextId", _contextId);
       return basis.getLibraryElement(source);
     } finally {
       instrumentation.log();
     }
   }
+
   List<Source> get librarySources {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getLibrarySources");
     try {
       instrumentation.metric3("contextId", _contextId);
       List<Source> ret = basis.librarySources;
       if (ret != null) {
         instrumentation.metric2("Source-count", ret.length);
       }
       return ret;
     } finally {
       instrumentation.log();
     }
   }
+
   LineInfo getLineInfo(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getLineInfo");
     try {
       instrumentation.metric3("contextId", _contextId);
       return basis.getLineInfo(source);
     } finally {
       instrumentation.log();
     }
   }
+
   Namespace getPublicNamespace(LibraryElement library) => basis.getPublicNamespace(library);
+
   Namespace getPublicNamespace2(Source source) => basis.getPublicNamespace2(source);
+
   List<Source> get refactoringUnsafeSources => basis.refactoringUnsafeSources;
+
   CompilationUnit getResolvedCompilationUnit(Source unitSource, LibraryElement library) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getResolvedCompilationUnit");
     try {
       instrumentation.metric3("contextId", _contextId);
       return basis.getResolvedCompilationUnit(unitSource, library);
     } finally {
       instrumentation.log();
     }
   }
+
   CompilationUnit getResolvedCompilationUnit2(Source unitSource, Source librarySource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getResolvedCompilationUnit");
     try {
       instrumentation.metric3("contextId", _contextId);
       return basis.getResolvedCompilationUnit2(unitSource, librarySource);
     } finally {
       instrumentation.log2(2);
     }
   }
+
   SourceFactory get sourceFactory {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getSourceFactory");
     try {
       instrumentation.metric3("contextId", _contextId);
       return basis.sourceFactory;
     } finally {
       instrumentation.log2(2);
     }
   }
+
   AnalysisContentStatistics get statistics => basis.statistics;
+
   TimestampedData<CompilationUnit> internalResolveCompilationUnit(Source unitSource, LibraryElement libraryElement) => basis.internalResolveCompilationUnit(unitSource, libraryElement);
+
   bool isClientLibrary(Source librarySource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-isClientLibrary");
     try {
       instrumentation.metric3("contextId", _contextId);
       return basis.isClientLibrary(librarySource);
     } finally {
       instrumentation.log();
     }
   }
+
   bool isServerLibrary(Source librarySource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-isServerLibrary");
     try {
       instrumentation.metric3("contextId", _contextId);
       return basis.isServerLibrary(librarySource);
     } finally {
       instrumentation.log();
     }
   }
+
   void mergeContext(AnalysisContext context) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-mergeContext");
     try {
       instrumentation.metric3("contextId", _contextId);
       if (context is InstrumentedAnalysisContextImpl) {
-        context = ((context as InstrumentedAnalysisContextImpl)).basis;
+        context = (context as InstrumentedAnalysisContextImpl).basis;
       }
       basis.mergeContext(context);
     } finally {
       instrumentation.log();
     }
   }
+
   CompilationUnit parseCompilationUnit(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-parseCompilationUnit");
     try {
       instrumentation.metric3("contextId", _contextId);
       return basis.parseCompilationUnit(source);
     } on AnalysisException catch (e) {
       recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
+
   HtmlUnit parseHtmlUnit(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-parseHtmlUnit");
     try {
       instrumentation.metric3("contextId", _contextId);
       return basis.parseHtmlUnit(source);
     } on AnalysisException catch (e) {
       recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
+
   AnalysisResult performAnalysisTask() {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-performAnalysisTask");
     try {
       instrumentation.metric3("contextId", _contextId);
       AnalysisResult result = basis.performAnalysisTask();
       if (result.changeNotices != null) {
         instrumentation.metric2("ChangeNotice-count", result.changeNotices.length);
       }
       return result;
     } finally {
       instrumentation.log2(2);
     }
   }
+
   void recordLibraryElements(Map<Source, LibraryElement> elementMap) {
     basis.recordLibraryElements(elementMap);
   }
+
   CompilationUnit resolveCompilationUnit(Source unitSource, LibraryElement library) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-resolveCompilationUnit");
     try {
       instrumentation.metric3("contextId", _contextId);
       return basis.resolveCompilationUnit(unitSource, library);
     } on AnalysisException catch (e) {
       recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
+
   CompilationUnit resolveCompilationUnit2(Source unitSource, Source librarySource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-resolveCompilationUnit");
     try {
       instrumentation.metric3("contextId", _contextId);
       return basis.resolveCompilationUnit2(unitSource, librarySource);
     } on AnalysisException catch (e) {
       recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
+
   HtmlUnit resolveHtmlUnit(Source htmlSource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-resolveHtmlUnit");
     try {
       instrumentation.metric3("contextId", _contextId);
       return basis.resolveHtmlUnit(htmlSource);
     } on AnalysisException catch (e) {
       recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
+
   void set analysisOptions(AnalysisOptions options) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-setAnalysisOptions");
     try {
       instrumentation.metric3("contextId", _contextId);
       basis.analysisOptions = options;
     } finally {
       instrumentation.log();
     }
   }
+
   void set analysisPriorityOrder(List<Source> sources) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-setAnalysisPriorityOrder");
     try {
       instrumentation.metric3("contextId", _contextId);
       basis.analysisPriorityOrder = sources;
     } finally {
       instrumentation.log();
     }
   }
+
   void setChangedContents(Source source, String contents, int offset, int oldLength, int newLength) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-setChangedContents");
     try {
       instrumentation.metric3("contextId", _contextId);
       basis.setChangedContents(source, contents, offset, oldLength, newLength);
     } finally {
       instrumentation.log();
     }
   }
+
   void setContents(Source source, String contents) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-setContents");
     try {
       instrumentation.metric3("contextId", _contextId);
       basis.setContents(source, contents);
     } finally {
       instrumentation.log();
     }
   }
+
   void set sourceFactory(SourceFactory factory) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-setSourceFactory");
     try {
       instrumentation.metric3("contextId", _contextId);
       basis.sourceFactory = factory;
     } finally {
       instrumentation.log();
     }
   }
+
   Iterable<Source> sourcesToResolve(List<Source> changedSources) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-sourcesToResolve");
     try {
       instrumentation.metric3("contextId", _contextId);
       return basis.sourcesToResolve(changedSources);
     } finally {
       instrumentation.log();
     }
   }
 }
+
 /**
  * The interface `InternalAnalysisContext` defines additional behavior for an analysis context
  * that is required by internal users of the context.
  */
 abstract class InternalAnalysisContext implements AnalysisContext {
-
   /**
    * Add the given source with the given information to this context.
    *
    * @param source the source to be added
    * @param info the information about the source
    */
   void addSourceInfo(Source source, SourceEntry info);
 
   /**
    * Return an array containing the sources of the libraries that are exported by the library with
@@ skipping 88 matching lines @@
 
   /**
    * Given a table mapping the source for the libraries represented by the corresponding elements to
    * the elements representing the libraries, record those mappings.
    *
    * @param elementMap a table mapping the source for the libraries represented by the elements to
    *          the elements representing the libraries
    */
   void recordLibraryElements(Map<Source, LibraryElement> elementMap);
 }
+
 /**
  * Container with global [AnalysisContext] performance statistics.
  */
 class PerformanceStatistics {
-
   /**
    * The [TimeCounter] for time spent in scanning.
    */
   static TimeCounter scan = new TimeCounter();
 
   /**
    * The [TimeCounter] for time spent in parsing.
    */
   static TimeCounter parse = new TimeCounter();
 
   /**
    * The [TimeCounter] for time spent in resolving.
    */
   static TimeCounter resolve = new TimeCounter();
 
   /**
    * The [TimeCounter] for time spent in error verifier.
    */
   static TimeCounter errors = new TimeCounter();
 
   /**
    * The [TimeCounter] for time spent in hints generator.
    */
   static TimeCounter hints = new TimeCounter();
 }
+
 /**
  * Instances of the class `RecordingErrorListener` implement an error listener that will
  * record the errors that are reported to it in a way that is appropriate for caching those errors
  * within an analysis context.
  *
  * @coverage dart.engine
  */
 class RecordingErrorListener implements AnalysisErrorListener {
-
   /**
    * A HashMap of lists containing the errors that were collected, keyed by each [Source].
    */
   Map<Source, Set<AnalysisError>> _errors = new Map<Source, Set<AnalysisError>>();
 
   /**
    * Add all of the errors recorded by the given listener to this listener.
    *
    * @param listener the listener that has recorded the errors to be added
    */
@@ skipping 29 matching lines @@
    * @return the errors collected by the listener for the passed [Source]
    */
   List<AnalysisError> getErrors2(Source source) {
     Set<AnalysisError> errorsForSource = _errors[source];
     if (errorsForSource == null) {
       return AnalysisError.NO_ERRORS;
     } else {
       return new List.from(errorsForSource);
     }
   }
+
   void onError(AnalysisError error) {
     Source source = error.source;
     Set<AnalysisError> errorsForSource = _errors[source];
     if (_errors[source] == null) {
       errorsForSource = new Set<AnalysisError>();
       _errors[source] = errorsForSource;
     }
     javaSetAdd(errorsForSource, error);
   }
 }
+
 /**
  * Instances of the class `ResolutionEraser` remove any resolution information from an AST
  * structure when used to visit that structure.
  */
 class ResolutionEraser extends GeneralizingASTVisitor<Object> {
   Object visitAssignmentExpression(AssignmentExpression node) {
     node.staticElement = null;
     node.propagatedElement = null;
     return super.visitAssignmentExpression(node);
   }
+
   Object visitBinaryExpression(BinaryExpression node) {
     node.staticElement = null;
     node.propagatedElement = null;
     return super.visitBinaryExpression(node);
   }
+
   Object visitCompilationUnit(CompilationUnit node) {
     node.element = null;
     return super.visitCompilationUnit(node);
   }
+
   Object visitConstructorDeclaration(ConstructorDeclaration node) {
     node.element = null;
     return super.visitConstructorDeclaration(node);
   }
+
   Object visitConstructorName(ConstructorName node) {
     node.staticElement = null;
     return super.visitConstructorName(node);
   }
+
   Object visitDirective(Directive node) {
     node.element = null;
     return super.visitDirective(node);
   }
+
   Object visitExpression(Expression node) {
     node.staticType = null;
     node.propagatedType = null;
     return super.visitExpression(node);
   }
+
   Object visitFunctionExpression(FunctionExpression node) {
     node.element = null;
     return super.visitFunctionExpression(node);
   }
+
   Object visitFunctionExpressionInvocation(FunctionExpressionInvocation node) {
     node.staticElement = null;
     node.propagatedElement = null;
     return super.visitFunctionExpressionInvocation(node);
   }
+
   Object visitIndexExpression(IndexExpression node) {
     node.staticElement = null;
     node.propagatedElement = null;
     return super.visitIndexExpression(node);
   }
+
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     node.staticElement = null;
     return super.visitInstanceCreationExpression(node);
   }
+
   Object visitPostfixExpression(PostfixExpression node) {
     node.staticElement = null;
     node.propagatedElement = null;
     return super.visitPostfixExpression(node);
   }
+
   Object visitPrefixExpression(PrefixExpression node) {
     node.staticElement = null;
     node.propagatedElement = null;
     return super.visitPrefixExpression(node);
   }
+
   Object visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
     node.staticElement = null;
     return super.visitRedirectingConstructorInvocation(node);
   }
+
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     node.staticElement = null;
     node.propagatedElement = null;
     return super.visitSimpleIdentifier(node);
   }
+
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     node.staticElement = null;
     return super.visitSuperConstructorInvocation(node);
   }
 }
+
 /**
  * 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> {
-
   /**
    * Initialize a newly created holder to hold the given values.
    *
    * @param modificationTime the modification time of the source from which the AST was created
    * @param unit the AST that was created from the source
    */
   ResolvableCompilationUnit(int modificationTime, CompilationUnit unit) : super(modificationTime, unit);
 
   /**
    * Return the AST that was created from the source.
    *
    * @return the AST that was created from the source
    */
   CompilationUnit get compilationUnit => data;
 }
+
 /**
  * Instances of the class `ResolvableHtmlUnit` represent an HTML unit that is not referenced
  * by any other objects and for which we have modification stamp information. It is used by the
  * [ResolveHtmlTask] to resolve an HTML source.
  */
 class ResolvableHtmlUnit extends TimestampedData<HtmlUnit> {
-
   /**
    * Initialize a newly created holder to hold the given values.
    *
    * @param modificationTime the modification time of the source from which the AST was created
    * @param unit the AST that was created from the source
    */
   ResolvableHtmlUnit(int modificationTime, HtmlUnit unit) : super(modificationTime, unit);
 
   /**
    * Return the AST that was created from the source.
    *
    * @return the AST that was created from the source
    */
   HtmlUnit get compilationUnit => data;
 }
+
 /**
  * Instances of the class `TimestampedData` represent analysis data for which we have a
  * modification time.
  */
 class TimestampedData<E> {
-
   /**
    * The modification time of the source from which the data was created.
    */
   int modificationTime = 0;
 
   /**
    * The data that was created from the source.
    */
   E data;
 
   /**
    * Initialize a newly created holder to hold the given values.
    *
    * @param modificationTime the modification time of the source from which the data was created
    * @param unit the data that was created from the source
    */
   TimestampedData(int modificationTime, E data) {
     this.modificationTime = modificationTime;
     this.data = data;
   }
 }
+
 /**
  * The abstract class `AnalysisTask` defines the behavior of objects used to perform an
  * analysis task.
  */
 abstract class AnalysisTask {
-
   /**
    * The context in which the task is to be performed.
    */
   InternalAnalysisContext context;
 
   /**
    * The exception that was thrown while performing this task, or `null` if the task completed
    * successfully.
    */
   AnalysisException exception;
@@ skipping 25 matching lines @@
    */
   Object perform(AnalysisTaskVisitor visitor) {
     try {
       safelyPerform();
     } on AnalysisException catch (exception) {
       this.exception = exception;
       AnalysisEngine.instance.logger.logInformation2("Task failed: ${taskDescription}", exception);
     }
     return accept(visitor);
   }
+
   String toString() => taskDescription;
 
   /**
    * Return a textual description of this task.
    *
    * @return a textual description of this task
    */
   String get taskDescription;
 
   /**
@@ skipping 12 matching lines @@
   void safelyPerform() {
     try {
       internalPerform();
     } on AnalysisException catch (exception) {
       throw exception;
     } on JavaException catch (exception) {
       throw new AnalysisException.con3(exception);
     }
   }
 }
+
 /**
  * The interface `AnalysisTaskVisitor` defines the behavior of objects that can visit tasks.
  * While tasks are not structured in any interesting way, this class provides the ability to
  * dispatch to an appropriate method.
  */
 abstract class AnalysisTaskVisitor<E> {
-
   /**
    * Visit a [GenerateDartErrorsTask].
    *
    * @param task the task to be visited
    * @return the result of visiting the task
    * @throws AnalysisException if the visitor throws an exception for some reason
    */
   E visitGenerateDartErrorsTask(GenerateDartErrorsTask task);
 
   /**
@@ skipping 52 matching lines @@
 
   /**
    * Visit a [ResolveHtmlTask].
    *
    * @param task the task to be visited
    * @return the result of visiting the task
    * @throws AnalysisException if the visitor throws an exception for some reason
    */
   E visitResolveHtmlTask(ResolveHtmlTask task);
 }
+
 /**
  * Instances of the class `GenerateDartErrorsTask` generate errors and warnings for a single
  * Dart source.
  */
 class GenerateDartErrorsTask extends AnalysisTask {
-
   /**
    * The source for which errors and warnings are to be produced.
    */
   Source source;
 
   /**
    * The element model for the library containing the source.
    */
   LibraryElement libraryElement;
 
@@ skipping 11 matching lines @@
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param source the source for which errors and warnings are to be produced
    * @param libraryElement the element model for the library containing the source
    */
   GenerateDartErrorsTask(InternalAnalysisContext context, Source source, LibraryElement libraryElement) : super(context) {
     this.source = source;
     this.libraryElement = libraryElement;
   }
+
   accept(AnalysisTaskVisitor visitor) => visitor.visitGenerateDartErrorsTask(this);
+
   String get taskDescription => "generate errors and warnings for ${source.fullName}";
+
   void internalPerform() {
     InternalAnalysisContext context = this.context;
     TimestampedData<CompilationUnit> data = context.internalResolveCompilationUnit(source, libraryElement);
     TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.errors.start();
     try {
       modificationTime = data.modificationTime;
       CompilationUnit unit = data.data;
       RecordingErrorListener errorListener = new RecordingErrorListener();
       ErrorReporter errorReporter = new ErrorReporter(errorListener, source);
       Source coreSource = context.sourceFactory.forUri(DartSdk.DART_CORE);
       LibraryElement coreLibrary = context.getLibraryElement(coreSource);
       TypeProvider typeProvider = new TypeProviderImpl(coreLibrary);
       ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, typeProvider);
       unit.accept(constantVerifier);
       ErrorVerifier errorVerifier = new ErrorVerifier(errorReporter, libraryElement, typeProvider, new InheritanceManager(libraryElement));
       unit.accept(errorVerifier);
       errors = errorListener.getErrors2(source);
     } finally {
       timeCounter.stop();
     }
   }
 }
+
 /**
  * Instances of the class `GenerateDartHintsTask` generate hints for a single Dart library.
  */
 class GenerateDartHintsTask extends AnalysisTask {
-
   /**
    * The element model for the library being analyzed.
    */
   LibraryElement libraryElement;
 
   /**
    * A table mapping the sources that were analyzed to the hints that were generated for the
    * sources.
    */
   Map<Source, TimestampedData<List<AnalysisError>>> hintMap;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param libraryElement the element model for the library being analyzed
    */
   GenerateDartHintsTask(InternalAnalysisContext context, LibraryElement libraryElement) : super(context) {
     this.libraryElement = libraryElement;
   }
+
   accept(AnalysisTaskVisitor visitor) => visitor.visitGenerateDartHintsTask(this);
+
   String get taskDescription {
     Source librarySource = libraryElement.source;
     if (librarySource == null) {
       return "generate Dart hints for library without source";
     }
     return "generate Dart hints for ${librarySource.fullName}";
   }
+
   void internalPerform() {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     List<CompilationUnitElement> parts = libraryElement.parts;
     int partCount = parts.length;
     List<CompilationUnit> compilationUnits = new List<CompilationUnit>(partCount + 1);
     Map<Source, TimestampedData<CompilationUnit>> timestampMap = new Map<Source, TimestampedData<CompilationUnit>>();
     Source unitSource = libraryElement.definingCompilationUnit.source;
     TimestampedData<CompilationUnit> resolvedUnit = getCompilationUnit(unitSource);
     timestampMap[unitSource] = resolvedUnit;
     CompilationUnit unit = resolvedUnit.data;
@@ skipping 24 matching lines @@
 
   /**
    * Return the resolved compilation unit associated with the given source.
    *
    * @param unitSource the source for the compilation unit whose resolved AST is to be returned
    * @return the resolved compilation unit associated with the given source
    * @throws AnalysisException if the resolved compilation unit could not be computed
    */
   TimestampedData<CompilationUnit> getCompilationUnit(Source unitSource) => context.internalResolveCompilationUnit(unitSource, libraryElement);
 }
+
 /**
  * Instances of the class `IncrementalAnalysisTask` incrementally update existing analysis.
  */
 class IncrementalAnalysisTask extends AnalysisTask {
-
   /**
    * The information used to perform incremental analysis.
    */
   IncrementalAnalysisCache cache;
 
   /**
    * The compilation unit that was produced by incrementally updating the existing unit.
    */
   CompilationUnit compilationUnit;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param cache the incremental analysis cache used to perform the analysis
    */
   IncrementalAnalysisTask(InternalAnalysisContext context, IncrementalAnalysisCache cache) : super(context) {
     this.cache = cache;
   }
+
   accept(AnalysisTaskVisitor visitor) => visitor.visitIncrementalAnalysisTask(this);
 
   /**
    * Return the source that is to be incrementally analyzed.
    *
    * @return the source
    */
   Source get source => cache != null ? cache.source : null;
+
   String get taskDescription => "incremental analysis ${(cache != null ? cache.source : "null")}";
+
   void internalPerform() {
     if (cache == null) {
       return;
     }
     compilationUnit = cache.resolvedUnit;
   }
 }
+
 /**
  * Instances of the class `ParseDartTask` parse a specific source as a Dart file.
  */
 class ParseDartTask extends AnalysisTask {
-
   /**
    * The source to be parsed.
    */
   Source source;
 
   /**
    * The time at which the contents of the source were last modified.
    */
   int modificationTime = -1;
 
@@ skipping 39 matching lines @@
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be parsed
    */
   ParseDartTask(InternalAnalysisContext context, Source source) : super(context) {
     this.source = source;
   }
+
   accept(AnalysisTaskVisitor visitor) => visitor.visitParseDartTask(this);
 
   /**
    * Return an array containing the sources referenced by 'export' directives, or an empty array if
    * the task has not yet been performed or if an exception occurred.
    *
    * @return an array containing the sources referenced by 'export' directives
    */
   List<Source> get exportedSources => toArray(_exportedSources);
 
@@ skipping 21 matching lines @@
    */
   bool hasLibraryDirective() => _hasLibraryDirective2;
 
   /**
    * Return `true` if the source contains a 'part of' directive, or `false` if the task
    * has not yet been performed or if an exception occurred.
    *
    * @return `true` if the source contains a 'part of' directive
    */
   bool hasPartOfDirective() => _hasPartOfDirective2;
+
   String get taskDescription {
     if (source == null) {
       return "parse as dart null source";
     }
     return "parse as dart ${source.fullName}";
   }
+
   void internalPerform() {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     List<Token> token = [null];
     TimeCounter_TimeCounterHandle timeCounterScan = PerformanceStatistics.scan.start();
     try {
-      Source_ContentReceiver receiver = new Source_ContentReceiver_11(this, errorListener, token);
+      Source_ContentReceiver receiver = new Source_ContentReceiver_12(this, errorListener, token);
       try {
         source.getContents(receiver);
       } on JavaException catch (exception) {
         modificationTime = source.modificationStamp;
         throw new AnalysisException.con3(exception);
       }
     } finally {
       timeCounterScan.stop();
     }
     TimeCounter_TimeCounterHandle timeCounterParse = PerformanceStatistics.parse.start();
@@ skipping 62 matching lines @@
    * @return an array containing all of the sources in the given set
    */
   List<Source> toArray(Set<Source> sources) {
     int size = sources.length;
     if (size == 0) {
       return Source.EMPTY_ARRAY;
     }
     return new List.from(sources);
   }
 }
-class Source_ContentReceiver_11 implements Source_ContentReceiver {
+
+class Source_ContentReceiver_12 implements Source_ContentReceiver {
   final ParseDartTask ParseDartTask_this;
+
   RecordingErrorListener errorListener;
+
   List<Token> token;
-  Source_ContentReceiver_11(this.ParseDartTask_this, this.errorListener, this.token);
+
+  Source_ContentReceiver_12(this.ParseDartTask_this, this.errorListener, this.token);
+
   void accept(CharBuffer contents, int modificationTime) {
     ParseDartTask_this.modificationTime = modificationTime;
     Scanner scanner = new Scanner(ParseDartTask_this.source, new CharSequenceReader(contents), errorListener);
     token[0] = scanner.tokenize();
     ParseDartTask_this.lineInfo = new LineInfo(scanner.lineStarts);
   }
+
   void accept2(String contents, int modificationTime) {
     ParseDartTask_this.modificationTime = modificationTime;
     Scanner scanner = new Scanner(ParseDartTask_this.source, new CharSequenceReader(new CharSequence(contents)), errorListener);
     token[0] = scanner.tokenize();
     ParseDartTask_this.lineInfo = new LineInfo(scanner.lineStarts);
   }
 }
+
 /**
  * Instances of the class `ParseHtmlTask` parse a specific source as an HTML file.
  */
 class ParseHtmlTask extends AnalysisTask {
-
   /**
    * The source to be parsed.
    */
   Source source;
 
   /**
    * The time at which the contents of the source were last modified.
    */
   int modificationTime = -1;
 
@@ skipping 35 matching lines @@
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be parsed
    */
   ParseHtmlTask(InternalAnalysisContext context, Source source) : super(context) {
     this.source = source;
   }
+
   accept(AnalysisTaskVisitor visitor) => visitor.visitParseHtmlTask(this);
+
   String get taskDescription {
     if (source == null) {
       return "parse as html null source";
     }
     return "parse as html ${source.fullName}";
   }
+
   void internalPerform() {
     HtmlScanner scanner = new HtmlScanner(source);
     try {
       source.getContents(scanner);
     } on JavaException catch (exception) {
       throw new AnalysisException.con3(exception);
     }
     HtmlScanResult scannerResult = scanner.result;
     modificationTime = scannerResult.modificationTime;
     lineInfo = new LineInfo(scannerResult.lineStarts);
     HtmlParseResult result = new HtmlParser(source).parse(scannerResult);
     htmlUnit = result.htmlUnit;
     referencedLibraries = librarySources;
   }
 
   /**
    * Return the sources of libraries that are referenced in the specified HTML file.
    *
    * @return the sources of libraries that are referenced in the HTML file
    */
   List<Source> get librarySources {
     List<Source> libraries = new List<Source>();
-    htmlUnit.accept(new RecursiveXmlVisitor_12(this, libraries));
+    htmlUnit.accept(new RecursiveXmlVisitor_13(this, libraries));
     if (libraries.isEmpty) {
       return Source.EMPTY_ARRAY;
     }
     return new List.from(libraries);
   }
 }
-class RecursiveXmlVisitor_12 extends RecursiveXmlVisitor<Object> {
+
+class RecursiveXmlVisitor_13 extends RecursiveXmlVisitor<Object> {
   final ParseHtmlTask ParseHtmlTask_this;
+
   List<Source> libraries;
-  RecursiveXmlVisitor_12(this.ParseHtmlTask_this, this.libraries) : super();
+
+  RecursiveXmlVisitor_13(this.ParseHtmlTask_this, this.libraries) : super();
+
   Object visitXmlTagNode(XmlTagNode node) {
     if (javaStringEqualsIgnoreCase(node.tag.lexeme, ParseHtmlTask._TAG_SCRIPT)) {
       bool isDartScript = false;
       XmlAttributeNode scriptAttribute = null;
       for (XmlAttributeNode attribute in node.attributes) {
         if (javaStringEqualsIgnoreCase(attribute.name.lexeme, ParseHtmlTask._ATTRIBUTE_SRC)) {
           scriptAttribute = attribute;
         } else if (javaStringEqualsIgnoreCase(attribute.name.lexeme, ParseHtmlTask._ATTRIBUTE_TYPE)) {
           if (javaStringEqualsIgnoreCase(attribute.text, ParseHtmlTask._TYPE_DART)) {
             isDartScript = true;
           }
         }
       }
       if (isDartScript && scriptAttribute != null) {
         try {
           Uri uri = new Uri(path: scriptAttribute.text);
           String fileName = uri.path;
           Source librarySource = ParseHtmlTask_this.context.sourceFactory.resolveUri(ParseHtmlTask_this.source, fileName);
           if (librarySource != null && librarySource.exists()) {
             libraries.add(librarySource);
           }
         } on URISyntaxException catch (e) {
         }
       }
     }
     return super.visitXmlTagNode(node);
   }
 }
+
 /**
  * Instances of the class `ResolveDartLibraryTask` parse a specific Dart library.
  */
 class ResolveDartLibraryTask extends AnalysisTask {
-
   /**
    * The source representing the file whose compilation unit is to be returned.
    */
   Source unitSource;
 
   /**
    * The source representing the library to be resolved.
    */
   Source librarySource;
 
   /**
    * The library resolver holding information about the libraries that were resolved.
    */
   LibraryResolver libraryResolver;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param unitSource the source representing the file whose compilation unit is to be returned
    * @param librarySource the source representing the library to be resolved
    */
   ResolveDartLibraryTask(InternalAnalysisContext context, Source unitSource, Source librarySource) : super(context) {
     this.unitSource = unitSource;
     this.librarySource = librarySource;
   }
+
   accept(AnalysisTaskVisitor visitor) => visitor.visitResolveDartLibraryTask(this);
+
   String get taskDescription {
     if (librarySource == null) {
       return "resolve library null source";
     }
     return "resolve library ${librarySource.fullName}";
   }
+
   void internalPerform() {
     libraryResolver = new LibraryResolver(context);
     libraryResolver.resolveLibrary(librarySource, true);
   }
 }
+
 /**
  * Instances of the class `ResolveDartUnitTask` resolve a single Dart file based on a existing
  * element model.
  */
 class ResolveDartUnitTask extends AnalysisTask {
-
   /**
    * The source that is to be resolved.
    */
   Source source;
 
   /**
    * The element model for the library containing the source.
    */
   LibraryElement _libraryElement;
 
@@ skipping 11 matching lines @@
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be parsed
    * @param libraryElement the element model for the library containing the source
    */
   ResolveDartUnitTask(InternalAnalysisContext context, Source source, LibraryElement libraryElement) : super(context) {
     this.source = source;
     this._libraryElement = libraryElement;
   }
+
   accept(AnalysisTaskVisitor visitor) => visitor.visitResolveDartUnitTask(this);
 
   /**
    * Return the source for the library containing the source that is to be resolved.
    *
    * @return the source for the library containing the source that is to be resolved
    */
   Source get librarySource => _libraryElement.source;
+
   String get taskDescription {
     Source librarySource = _libraryElement.source;
     if (librarySource == null) {
       return "resolve unit null source";
     }
     return "resolve unit ${librarySource.fullName}";
   }
+
   void internalPerform() {
     Source coreLibrarySource = _libraryElement.context.sourceFactory.forUri(DartSdk.DART_CORE);
     LibraryElement coreElement = context.computeLibraryElement(coreLibrarySource);
     TypeProvider typeProvider = new TypeProviderImpl(coreElement);
     ResolvableCompilationUnit resolvableUnit = context.computeResolvableCompilationUnit(source);
     modificationTime = resolvableUnit.modificationTime;
     CompilationUnit unit = resolvableUnit.compilationUnit;
     if (unit == null) {
       throw new AnalysisException.con1("Internal error: computeResolvableCompilationUnit returned a value without a parsed Dart unit");
     }
@@ skipping 37 matching lines @@
       return element;
     }
     for (CompilationUnitElement partElement in libraryElement.parts) {
       if (partElement.source == unitSource) {
         return partElement;
       }
     }
     return null;
   }
 }
+
 /**
  * Instances of the class `ResolveHtmlTask` resolve a specific source as an HTML file.
  */
 class ResolveHtmlTask extends AnalysisTask {
-
   /**
    * The source to be resolved.
    */
   Source source;
 
   /**
    * The time at which the contents of the source were last modified.
    */
   int modificationTime = -1;
 
   /**
    * The element produced by resolving the source.
    */
   HtmlElement element = null;
 
   /**
    * The resolution errors that were discovered while resolving the source.
    */
   List<AnalysisError> resolutionErrors = AnalysisError.NO_ERRORS;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be resolved
    */
   ResolveHtmlTask(InternalAnalysisContext context, Source source) : super(context) {
     this.source = source;
   }
+
   accept(AnalysisTaskVisitor visitor) => visitor.visitResolveHtmlTask(this);
+
   String get taskDescription {
     if (source == null) {
       return "resolve as html null source";
     }
     return "resolve as html ${source.fullName}";
   }
+
   void internalPerform() {
     ResolvableHtmlUnit resolvableHtmlUnit = context.computeResolvableHtmlUnit(source);
     HtmlUnit unit = resolvableHtmlUnit.compilationUnit;
     if (unit == null) {
       throw new AnalysisException.con1("Internal error: computeResolvableHtmlUnit returned a value without a parsed HTML unit");
     }
     modificationTime = resolvableHtmlUnit.modificationTime;
     HtmlUnitBuilder builder = new HtmlUnitBuilder(context);
     element = builder.buildHtmlElement2(source, modificationTime, unit);
     resolutionErrors = builder.errorListener.getErrors2(source);
   }
 }
+
 /**
  * The interface `Logger` defines the behavior of objects that can be used to receive
  * information about errors within the analysis engine. Implementations usually write this
  * information to a file, but can also record the information for later use (such as during testing)
  * or even ignore the information.
  *
  * @coverage dart.engine.utilities
  */
 abstract class Logger {
   static final Logger NULL = new Logger_NullLogger();
@@ skipping 29 matching lines @@
   void logInformation(String message);
 
   /**
    * Log the given exception as one representing an informational message.
    *
    * @param message an explanation of why the error occurred or what it means
    * @param exception the exception being logged
    */
   void logInformation2(String message, Exception exception);
 }
+
 /**
  * Implementation of [Logger] that does nothing.
  */
 class Logger_NullLogger implements Logger {
   void logError(String message) {
   }
+
   void logError2(String message, Exception exception) {
   }
+
   void logError3(Exception exception) {
   }
+
   void logInformation(String message) {
   }
+
   void logInformation2(String message, Exception exception) {
   }
 }