New analyzer snapshot.

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

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine;
 
 import 'java_core.dart';
@@ skipping 109 matching lines @@
   void set logger(Logger logger) {
     this._logger = logger == null ? Logger.NULL : logger;
   }
 }
 
 /**
  * Container with statistics about the [AnalysisContext].
  */
 abstract class AnalysisContentStatistics {
   /**
+   * Return the statistics for each kind of cached data.
+   *
+   * @return the statistics for each kind of cached data
+   */
+  List<AnalysisContentStatistics_CacheRow> get cacheRows;
+
+  /**
    * Return the exceptions that caused some entries to have a state of [CacheState#ERROR].
    *
    * @return the exceptions that caused some entries to have a state of [CacheState#ERROR]
    */
   List<AnalysisException> get exceptions;
 
   /**
-   * Return the statistics for each kind of cached data.
+   * Return an array containing all of the sources in the cache.
    *
-   * @return the statistics for each kind of cached data
+   * @return an array containing all of the sources in the cache
    */
-  List<AnalysisContentStatistics_CacheRow> get cacheRows;
+  List<Source> get sources;
 }
 
 /**
  * Information about single item in the cache.
  */
 abstract class AnalysisContentStatistics_CacheRow {
   int get errorCount;
 
   int get flushedCount;
 
@@ skipping 122 matching lines @@
    *
    * @param source the source whose line information is to be returned
    * @return the line information for the given source
    * @throws AnalysisException if the line information could not be determined because the analysis
    *           could not be performed
    * @see #getLineInfo(Source)
    */
   LineInfo computeLineInfo(Source source);
 
   /**
+   * Return `true` if the given source exists.
+   *
+   * This method should be used rather than the method [Source#exists] because contexts can
+   * have local overrides of the content of a source that the source is not aware of and a source
+   * with local content is considered to exist even if there is no file on disk.
+   *
+   * @param source the source whose modification stamp is to be returned
+   * @return `true` if the source exists
+   */
+  bool exists(Source source);
+
+  /**
    * Create a new context in which analysis can be performed. Any sources in the specified container
    * will be removed from this context and added to the newly created context.
    *
    * @param container the container containing sources that should be removed from this context and
    *          added to the returned context
    * @return the analysis context that was created
    */
   AnalysisContext extractContext(SourceContainer container);
 
   /**
    * Return the set of analysis options controlling the behavior of this context. Clients should not
    * modify the returned set of options. The options should only be set by invoking the method
    * [setAnalysisOptions].
    *
    * @return the set of analysis options controlling the behavior of this context
    */
   AnalysisOptions get analysisOptions;
 
   /**
+   * Return the element model corresponding to the compilation unit defined by the given source in
+   * the library defined by the given source, or `null` if the element model does not
+   * currently exist or if the library cannot be analyzed for some reason.
+   *
+   * @param unitSource the source of the compilation unit
+   * @param librarySource the source of the defining compilation unit of the library containing the
+   *          compilation unit
+   * @return the element model corresponding to the compilation unit defined by the given source
+   */
+  CompilationUnitElement getCompilationUnitElement(Source unitSource, Source librarySource);
+
+  /**
+   * Get the contents and timestamp of the given source.
+   *
+   * This method should be used rather than the method [Source#getContents] because contexts
+   * can have local overrides of the content of a source that the source is not aware of.
+   *
+   * @param source the source whose content is to be returned
+   * @return the contents and timestamp of the source
+   * @throws Exception if the contents of the source could not be accessed
+   */
+  TimestampedData<String> getContents(Source source);
+
+  /**
+   * Get the contents of the given source and pass it to the given content receiver.
+   *
+   * This method should be used rather than the method [Source#getContentsToReceiver]
+   * because contexts can have local overrides of the content of a source that the source is not
+   * aware of.
+   *
+   * @param source the source whose content is to be returned
+   * @param receiver the content receiver to which the content of the source will be passed
+   * @throws Exception if the contents of the source could not be accessed
+   */
+  void getContents2(Source source, Source_ContentReceiver receiver);
+
+  /**
    * Return the element referenced by the given location, or `null` if the element is not
    * immediately available or if there is no element with the given location. The latter condition
    * can occur, for example, if the location describes an element from a different context or if the
    * element has been removed from this context as a result of some change since it was originally
    * obtained.
    *
    * @param location the reference describing the element to be returned
    * @return the element referenced by the given location
    */
   Element getElement(ElementLocation location);
@@ skipping 118 matching lines @@
    * not known. The line information is used to map offsets from the beginning of the source to line
    * and column pairs.
    *
    * @param source the source whose line information is to be returned
    * @return the line information for the given source
    * @see #computeLineInfo(Source)
    */
   LineInfo getLineInfo(Source source);
 
   /**
+   * Return the modification stamp for the given source. A modification stamp is a non-negative
+   * integer with the property that if the contents of the source have not been modified since the
+   * last time the modification stamp was accessed then the same value will be returned, but if the
+   * contents of the source have been modified one or more times (even if the net change is zero)
+   * the stamps will be different.
+   *
+   * This method should be used rather than the method [Source#getModificationStamp] because
+   * contexts can have local overrides of the content of a source that the source is not aware of.
+   *
+   * @param source the source whose modification stamp is to be returned
+   * @return the modification stamp for the source
+   */
+  int getModificationStamp(Source source);
+
+  /**
    * Return an array containing all of the sources known to this context and their resolution state
    * is not valid or flush. So, these sources are not safe to update during refactoring, because we
    * may be don't know all the references in them.
    *
    * @return the sources known to this context and are not safe for refactoring
    */
   List<Source> get refactoringUnsafeSources;
 
   /**
    * Return a fully resolved AST for a single compilation unit within the given library, or
@@ skipping 184 matching lines @@
 
   /**
    * Set the source factory used to create the sources that can be analyzed in this context to the
    * given source factory. Clients can safely assume that all analysis results have been
    * invalidated.
    *
    * @param factory the source factory used to create the sources that can be analyzed in this
    *          context
    */
   void set sourceFactory(SourceFactory factory);
-
-  /**
-   * 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.
    *
@@ skipping 44 matching lines @@
    */
   AnalysisException.con3(Exception cause) : super.withCause(cause);
 }
 
 /**
  * The interface `AnalysisOptions` defines the behavior of objects that provide access to a
  * set of analysis options used to control the behavior of an analysis context.
  */
 abstract class AnalysisOptions {
   /**
+   * Return `true` if analysis is to analyze Angular.
+   *
+   * @return `true` if analysis is to analyze Angular
+   */
+  bool get analyzeAngular;
+
+  /**
    * Return `true` if analysis is to parse and analyze function bodies.
    *
    * @return `true` if analysis is to parse and analyzer function bodies
    */
   bool get analyzeFunctionBodies;
 
   /**
    * 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.
    *
    * @return `true` if analysis is to generate dart2js related hint results
    */
   bool get dart2jsHint;
 
   /**
+   * Return `true` if errors, warnings and hints should be generated for sources in the SDK.
+   * The default value is `false`.
+   *
+   * @return `true` if errors, warnings and hints should be generated for the SDK
+   */
+  bool get generateSdkErrors;
+
+  /**
    * Return `true` if analysis is to generate hint results (e.g. type inference based
    * information and pub best practices).
    *
    * @return `true` if analysis is to generate hint results
    */
   bool get hint;
 
   /**
    * Return `true` if incremental analysis should be used.
    *
    * @return `true` if incremental analysis should be used
    */
   bool get incremental;
 
   /**
    * Return `true` if analysis is to parse comments.
    *
    * @return `true` if analysis is to parse comments
    */
   bool get preserveComments;
-
-  /**
-   * Return `true` if analysis is to analyze Angular.
-   *
-   * @return `true` if analysis is to analyze Angular
-   */
-  bool get analyzeAngular;
 }
 
 /**
  * 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.
    */
@@ skipping 187 matching lines @@
     for (Source source in sources) {
       builder.append(prefix);
       builder.append(source.fullName);
       prefix = ", ";
     }
     return true;
   }
 }
 
 /**
+ * Instances of the class `ObsoleteSourceAnalysisException` represent an analysis attempt that
+ * failed because a source was deleted between the time the analysis started and the time the
+ * results of the analysis were ready to be recorded.
+ */
+class ObsoleteSourceAnalysisException extends AnalysisException {
+  /**
+   * The source that was removed while it was being analyzed.
+   */
+  Source _source;
+
+  /**
+   * Initialize a newly created exception to represent the removal of the given source.
+   *
+   * @param source the source that was removed while it was being analyzed
+   */
+  ObsoleteSourceAnalysisException(Source source) : super.con1("The source '${source.fullName}' was removed while it was being analyzed") {
+    this._source = source;
+  }
+
+  /**
+   * Return the source that was removed while it was being analyzed.
+   *
+   * @return the source that was removed
+   */
+  Source get source => _source;
+}
+
+/**
  * 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>();
 
   /**
@@ skipping 173 matching lines @@
     }
     if (sourceToRemove < 0) {
       AnalysisEngine.instance.logger.logError2("Internal error: Could not flush data from the cache", new JavaException());
       return null;
     }
     return _recentlyUsed.removeAt(sourceToRemove);
   }
 }
 
 /**
- * Information about Angular application.
- */
-class AngularApplicationInfo {
-  final Source entryPoint;
-
-  final List<AngularElement> elements;
-
-  AngularApplicationInfo(this.entryPoint, this.elements);
-}
-
-/**
  * 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
@@ skipping 143 matching lines @@
    * The data descriptor representing the resolved AST structure.
    */
   static final DataDescriptor<CompilationUnit> RESOLVED_UNIT = new DataDescriptor<CompilationUnit>("DartEntry.RESOLVED_UNIT");
 
   /**
    * The data descriptor representing the source kind.
    */
   static final DataDescriptor<SourceKind> SOURCE_KIND = new DataDescriptor<SourceKind>("DartEntry.SOURCE_KIND");
 
   /**
+   * The data descriptor representing the token stream.
+   */
+  static final DataDescriptor<List<AnalysisError>> SCAN_ERRORS = new DataDescriptor<List<AnalysisError>>("DartEntry.SCAN_ERRORS");
+
+  /**
+   * The data descriptor representing the token stream.
+   */
+  static final DataDescriptor<Token> TOKEN_STREAM = new DataDescriptor<Token>("DartEntry.TOKEN_STREAM");
+
+  /**
    * The data descriptor representing the errors resulting from verifying the source.
    */
   static final DataDescriptor<List<AnalysisError>> VERIFICATION_ERRORS = new DataDescriptor<List<AnalysisError>>("DartEntry.VERIFICATION_ERRORS");
 
   /**
+   * The data descriptor representing the errors reported during Angular resolution.
+   */
+  static final DataDescriptor<List<AnalysisError>> ANGULAR_ERRORS = new DataDescriptor<List<AnalysisError>>("DartEntry.ANGULAR_ERRORS");
+
+  /**
    * Return all of the errors associated with the compilation unit that are currently cached.
    *
    * @return all of the errors associated with the compilation unit
    */
   List<AnalysisError> get allErrors;
 
   /**
    * Return a valid parsed compilation unit, either an unresolved AST structure or the result of
    * resolving the AST structure in the context of some library, or `null` if there is no
    * parsed compilation unit available.
@@ skipping 50 matching lines @@
   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 token stream.
+   */
+  CacheState _tokenStreamState = CacheState.INVALID;
+
+  /**
+   * The head of the token stream, or `null` if the token stream is not currently cached.
+   */
+  Token _tokenStream;
+
+  /**
+   * The state of the cached scan errors.
+   */
+  CacheState _scanErrorsState = CacheState.INVALID;
+
+  /**
+   * The errors produced while scanning the compilation unit, or `null` if the errors are not
+   * currently cached.
+   */
+  List<AnalysisError> _scanErrors = AnalysisError.NO_ERRORS;
+
+  /**
    * The state of the cached source kind.
    */
   CacheState _sourceKindState = CacheState.INVALID;
 
   /**
    * The kind of this source.
    */
   SourceKind _sourceKind = SourceKind.UNKNOWN;
 
   /**
@@ skipping 12 matching lines @@
    * cached.
    */
   CompilationUnit _parsedUnit;
 
   /**
    * The state of the cached parse errors.
    */
   CacheState _parseErrorsState = CacheState.INVALID;
 
   /**
-   * The errors produced while scanning and parsing the compilation unit, or `null` if the
-   * errors are not currently cached.
+   * The errors produced while parsing the compilation unit, or `null` if the errors are not
+   * currently cached.
    */
   List<AnalysisError> _parseErrors = AnalysisError.NO_ERRORS;
 
   /**
    * The state of the cached list of imported libraries.
    */
   CacheState _importedLibrariesState = CacheState.INVALID;
 
   /**
    * The list of libraries imported by the library, or an empty array if the list is not currently
@@ skipping 64 matching lines @@
    * The state of the cached launchable flag.
    */
   CacheState _launchableState = CacheState.INVALID;
 
   /**
    * An integer holding bit masks such as [LAUNCHABLE] and [CLIENT_CODE].
    */
   int _bitmask = 0;
 
   /**
+   * The error produced while performing Angular resolution, or an empty array if there are no
+   * errors if the error are not currently cached.
+   */
+  List<AnalysisError> _angularErrors = AnalysisError.NO_ERRORS;
+
+  /**
    * The index of the bit in the [bitmask] indicating that this library is launchable: that
    * the file has a main method.
    */
   static int _LAUNCHABLE_INDEX = 1;
 
   /**
    * The index of the bit in the [bitmask] indicating that the library is client code: that
    * the library depends on the html library. If the library is not "client code", then it is
    * referred to as "server code".
    */
   static int _CLIENT_CODE_INDEX = 2;
 
   /**
    * Add the given library to the list of libraries that contain this part. This method should only
    * be invoked on entries that represent a part.
    *
    * @param librarySource the source of the library to be added
    */
   void addContainingLibrary(Source librarySource) {
     _containingLibraries.add(librarySource);
   }
 
   /**
    * Flush any AST structures being maintained by this entry.
    */
   void flushAstStructures() {
+    if (identical(_tokenStreamState, CacheState.VALID)) {
+      _tokenStreamState = CacheState.FLUSHED;
+      _tokenStream = null;
+    }
     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);
-    }
+    ListUtilities.addAll(errors, _scanErrors);
+    ListUtilities.addAll(errors, _parseErrors);
     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);
-      }
+      ListUtilities.addAll(errors, state._resolutionErrors);
+      ListUtilities.addAll(errors, state._verificationErrors);
+      ListUtilities.addAll(errors, state._hints);
       state = state._nextState;
     }
-    ;
+    ListUtilities.addAll(errors, _angularErrors);
     if (errors.length == 0) {
       return AnalysisError.NO_ERRORS;
     }
     return new List.from(errors);
   }
 
   CompilationUnit get anyParsedCompilationUnit {
     if (identical(_parsedUnitState, CacheState.VALID)) {
       _parsedUnitAccessed = true;
       return _parsedUnit;
@@ skipping 70 matching lines @@
     } 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.SCAN_ERRORS)) {
+      return _scanErrorsState;
     } else if (identical(descriptor, DartEntry.SOURCE_KIND)) {
       return _sourceKindState;
+    } else if (identical(descriptor, DartEntry.TOKEN_STREAM)) {
+      return _tokenStreamState;
     } else {
       return super.getState(descriptor);
     }
   }
 
   CacheState getState2(DataDescriptor descriptor, Source librarySource) {
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
       if (librarySource == state._librarySource) {
         if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
@@ skipping 12 matching lines @@
     }
     ;
     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.CONTAINING_LIBRARIES)) {
+    if (identical(descriptor, DartEntry.ANGULAR_ERRORS)) {
+      return _angularErrors;
+    } else if (identical(descriptor, DartEntry.CONTAINING_LIBRARIES)) {
       return new List.from(_containingLibraries);
     } else if (identical(descriptor, DartEntry.ELEMENT)) {
       return _element;
     } else if (identical(descriptor, DartEntry.EXPORTED_LIBRARIES)) {
       return _exportedLibraries;
     } else if (identical(descriptor, DartEntry.IMPORTED_LIBRARIES)) {
       return _importedLibraries;
     } else if (identical(descriptor, DartEntry.INCLUDED_PARTS)) {
       return _includedParts;
     } else if (identical(descriptor, DartEntry.IS_CLIENT)) {
       return BooleanArray.get2(_bitmask, _CLIENT_CODE_INDEX);
     } else if (identical(descriptor, DartEntry.IS_LAUNCHABLE)) {
       return BooleanArray.get2(_bitmask, _LAUNCHABLE_INDEX);
     } else if (identical(descriptor, DartEntry.PARSE_ERRORS)) {
       return _parseErrors;
     } else if (identical(descriptor, DartEntry.PARSED_UNIT)) {
       _parsedUnitAccessed = true;
       return _parsedUnit;
     } else if (identical(descriptor, DartEntry.PUBLIC_NAMESPACE)) {
       return _publicNamespace;
+    } else if (identical(descriptor, DartEntry.SCAN_ERRORS)) {
+      return _scanErrors;
     } else if (identical(descriptor, DartEntry.SOURCE_KIND)) {
       return _sourceKind;
+    } else if (identical(descriptor, DartEntry.TOKEN_STREAM)) {
+      return _tokenStream;
     }
     return super.getValue(descriptor);
   }
 
   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;
@@ skipping 37 matching lines @@
     } else if (identical(descriptor, DartEntry.IS_CLIENT)) {
       return identical(_clientServerState, CacheState.INVALID);
     } else if (identical(descriptor, DartEntry.IS_LAUNCHABLE)) {
       return identical(_launchableState, CacheState.INVALID);
     } else if (identical(descriptor, DartEntry.PARSE_ERRORS)) {
       return identical(_parseErrorsState, CacheState.INVALID);
     } else if (identical(descriptor, DartEntry.PARSED_UNIT)) {
       return identical(_parsedUnitState, CacheState.INVALID);
     } else if (identical(descriptor, DartEntry.PUBLIC_NAMESPACE)) {
       return identical(_publicNamespaceState, CacheState.INVALID);
+    } else if (identical(descriptor, DartEntry.SCAN_ERRORS)) {
+      return identical(_scanErrorsState, CacheState.INVALID);
     } else if (identical(descriptor, DartEntry.SOURCE_KIND)) {
       return identical(_sourceKindState, CacheState.INVALID);
+    } else if (identical(descriptor, DartEntry.TOKEN_STREAM)) {
+      return identical(_tokenStreamState, CacheState.INVALID);
     } else if (identical(descriptor, DartEntry.RESOLUTION_ERRORS) || identical(descriptor, DartEntry.RESOLVED_UNIT) || identical(descriptor, DartEntry.VERIFICATION_ERRORS) || identical(descriptor, DartEntry.HINTS)) {
       DartEntryImpl_ResolutionState state = _resolutionState;
       while (state != null) {
         if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
           return identical(state._resolutionErrorsState, CacheState.INVALID);
         } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
           return identical(state._resolvedUnitState, CacheState.INVALID);
         } else if (identical(descriptor, DartEntry.VERIFICATION_ERRORS)) {
           return identical(state._verificationErrorsState, CacheState.INVALID);
         } else if (identical(descriptor, DartEntry.HINTS)) {
           return identical(state._hintsState, CacheState.INVALID);
         }
       }
       return false;
     } else {
       return identical(super.getState(descriptor), CacheState.INVALID);
     }
   }
 
   void invalidateAllInformation() {
     super.invalidateAllInformation();
+    _scanErrors = AnalysisError.NO_ERRORS;
+    _scanErrorsState = CacheState.INVALID;
+    _tokenStream = null;
+    _tokenStreamState = CacheState.INVALID;
     _sourceKind = SourceKind.UNKNOWN;
     _sourceKindState = CacheState.INVALID;
     _parseErrors = AnalysisError.NO_ERRORS;
     _parseErrorsState = CacheState.INVALID;
     _parsedUnit = null;
     _parsedUnitAccessed = false;
     _parsedUnitState = CacheState.INVALID;
     discardCachedResolutionInformation();
   }
 
@@ skipping 72 matching lines @@
       _includedPartsState = CacheState.INVALID;
     }
   }
 
   /**
    * Record that an error occurred while attempting to scan or parse the entry represented by this
    * entry. This will set the state of all information, including any resolution-based information,
    * as being in error.
    */
   void recordParseError() {
-    setState(SourceEntry.LINE_INFO, CacheState.ERROR);
     _sourceKind = SourceKind.UNKNOWN;
     _sourceKindState = CacheState.ERROR;
     _parseErrors = AnalysisError.NO_ERRORS;
     _parseErrorsState = CacheState.ERROR;
     _parsedUnit = null;
     _parsedUnitAccessed = false;
     _parsedUnitState = CacheState.ERROR;
     recordDependencyError();
     recordResolutionError();
   }
 
   /**
    * Record that the parse-related information for the associated source is about to be computed by
    * the current thread.
    */
   void recordParseInProcess() {
-    if (getState(SourceEntry.LINE_INFO) != CacheState.VALID) {
-      setState(SourceEntry.LINE_INFO, CacheState.IN_PROCESS);
-    }
     if (_sourceKindState != CacheState.VALID) {
       _sourceKindState = CacheState.IN_PROCESS;
     }
     if (_parseErrorsState != CacheState.VALID) {
       _parseErrorsState = CacheState.IN_PROCESS;
     }
     if (_parsedUnitState != CacheState.VALID) {
       _parsedUnitState = CacheState.IN_PROCESS;
     }
   }
@@ skipping 47 matching lines @@
     if (identical(_launchableState, CacheState.IN_PROCESS)) {
       _launchableState = CacheState.INVALID;
     }
     if (identical(_publicNamespaceState, CacheState.IN_PROCESS)) {
       _publicNamespaceState = CacheState.INVALID;
     }
     _resolutionState.recordResolutionNotInProcess();
   }
 
   /**
+   * Record that an error occurred while attempting to scan or parse the entry represented by this
+   * entry. This will set the state of all information, including any resolution-based information,
+   * as being in error.
+   */
+  void recordScanError() {
+    setState(SourceEntry.LINE_INFO, CacheState.ERROR);
+    _scanErrors = AnalysisError.NO_ERRORS;
+    _scanErrorsState = CacheState.ERROR;
+    _tokenStream = null;
+    _tokenStreamState = CacheState.ERROR;
+    recordParseError();
+  }
+
+  /**
+   * Record that the scan-related information for the associated source is about to be computed by
+   * the current thread.
+   */
+  void recordScanInProcess() {
+    if (getState(SourceEntry.LINE_INFO) != CacheState.VALID) {
+      setState(SourceEntry.LINE_INFO, CacheState.IN_PROCESS);
+    }
+    if (_scanErrorsState != CacheState.VALID) {
+      _scanErrorsState = CacheState.IN_PROCESS;
+    }
+    if (_tokenStreamState != CacheState.VALID) {
+      _tokenStreamState = CacheState.IN_PROCESS;
+    }
+  }
+
+  /**
+   * Record that an in-process scan has stopped without recording results because the results were
+   * invalidated before they could be recorded.
+   */
+  void recordScanNotInProcess() {
+    if (identical(getState(SourceEntry.LINE_INFO), CacheState.IN_PROCESS)) {
+      setState(SourceEntry.LINE_INFO, CacheState.INVALID);
+    }
+    if (identical(_scanErrorsState, CacheState.IN_PROCESS)) {
+      _scanErrorsState = CacheState.INVALID;
+    }
+    if (identical(_tokenStreamState, CacheState.IN_PROCESS)) {
+      _tokenStreamState = CacheState.INVALID;
+    }
+  }
+
+  /**
    * Remove the given library from the list of libraries that contain this part. This method should
    * only be invoked on entries that represent a part.
    *
    * @param librarySource the source of the library to be removed
    */
   void removeContainingLibrary(Source librarySource) {
     _containingLibraries.remove(librarySource);
   }
 
   /**
@@ skipping 30 matching lines @@
    * Set the list of libraries that contain this compilation unit to contain only the given source.
    * This method should only be invoked on entries that represent a library.
    *
    * @param librarySource the source of the single library that the list should contain
    */
   void set containingLibrary(Source librarySource) {
     _containingLibraries.clear();
     _containingLibraries.add(librarySource);
   }
 
-  /**
-   * Set the results of parsing the compilation unit at the given time to the given values.
-   *
-   * @param modificationStamp the earliest time at which the source was last modified before the
-   *          parsing was started
-   * @param lineInfo the line information resulting from parsing the compilation unit
-   * @param unit the AST structure resulting from parsing the compilation unit
-   * @param errors the parse errors resulting from parsing the compilation unit
-   */
-  void setParseResults(int modificationStamp, LineInfo lineInfo, CompilationUnit unit, List<AnalysisError> errors) {
-    if (getState(SourceEntry.LINE_INFO) != CacheState.VALID) {
-      setValue(SourceEntry.LINE_INFO, lineInfo);
-    }
-    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 12 matching lines @@
     } else if (identical(descriptor, DartEntry.PARSED_UNIT)) {
       CompilationUnit newUnit = updatedValue(state, _parsedUnit, null);
       if (newUnit != _parsedUnit) {
         _parsedUnitAccessed = false;
       }
       _parsedUnit = newUnit;
       _parsedUnitState = state;
     } else if (identical(descriptor, DartEntry.PUBLIC_NAMESPACE)) {
       _publicNamespace = updatedValue(state, _publicNamespace, null);
       _publicNamespaceState = state;
+    } else if (identical(descriptor, DartEntry.SCAN_ERRORS)) {
+      _scanErrors = updatedValue(state, _scanErrors, AnalysisError.NO_ERRORS);
+      _scanErrorsState = state;
     } else if (identical(descriptor, DartEntry.SOURCE_KIND)) {
       _sourceKind = updatedValue(state, _sourceKind, SourceKind.UNKNOWN);
       _sourceKindState = state;
+    } else if (identical(descriptor, DartEntry.TOKEN_STREAM)) {
+      _tokenStream = updatedValue(state, _tokenStream, null);
+      _tokenStreamState = state;
     } else {
       super.setState(descriptor, state);
     }
   }
 
   /**
    * Set the state of the data represented by the given descriptor in the context of the given
    * library to the given state.
    *
    * @param descriptor the descriptor representing the data whose state is to be set
@@ skipping 14 matching lines @@
       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)) {
+    if (identical(descriptor, DartEntry.ANGULAR_ERRORS)) {
+      _angularErrors = value == null ? AnalysisError.NO_ERRORS : (value as List<AnalysisError>);
+    } else 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;
     } else if (identical(descriptor, DartEntry.INCLUDED_PARTS)) {
       _includedParts = value == null ? Source.EMPTY_ARRAY : (value as List<Source>);
       _includedPartsState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.IS_CLIENT)) {
       _bitmask = BooleanArray.set2(_bitmask, _CLIENT_CODE_INDEX, value as bool);
       _clientServerState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.IS_LAUNCHABLE)) {
       _bitmask = BooleanArray.set2(_bitmask, _LAUNCHABLE_INDEX, value as bool);
       _launchableState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.PARSE_ERRORS)) {
       _parseErrors = value == null ? AnalysisError.NO_ERRORS : (value as List<AnalysisError>);
       _parseErrorsState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.PARSED_UNIT)) {
       _parsedUnit = value as CompilationUnit;
       _parsedUnitAccessed = false;
       _parsedUnitState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.PUBLIC_NAMESPACE)) {
       _publicNamespace = value as Namespace;
       _publicNamespaceState = CacheState.VALID;
+    } else if (identical(descriptor, DartEntry.SCAN_ERRORS)) {
+      _scanErrors = value == null ? AnalysisError.NO_ERRORS : (value as List<AnalysisError>);
+      _scanErrorsState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.SOURCE_KIND)) {
       _sourceKind = value as SourceKind;
       _sourceKindState = CacheState.VALID;
+    } else if (identical(descriptor, DartEntry.TOKEN_STREAM)) {
+      _tokenStream = value as Token;
+      _tokenStreamState = CacheState.VALID;
     } else {
       super.setValue(descriptor, value);
     }
   }
 
   /**
    * Set the value of the data represented by the given descriptor in the context of the given
    * library to the given value, and set the state of that data to [CacheState#VALID].
    *
    * @param descriptor the descriptor representing which data is to have its value set
@@ skipping 14 matching lines @@
       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;
+    _scanErrorsState = other._scanErrorsState;
+    _scanErrors = other._scanErrors;
+    _tokenStreamState = other._tokenStreamState;
+    _tokenStream = other._tokenStream;
     _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;
     _containingLibraries = new List<Source>.from(other._containingLibraries);
     _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;
+    _angularErrors = other._angularErrors;
   }
 
-  bool hasErrorState() => super.hasErrorState() || identical(_sourceKindState, CacheState.ERROR) || identical(_parsedUnitState, CacheState.ERROR) || identical(_parseErrorsState, CacheState.ERROR) || identical(_importedLibrariesState, CacheState.ERROR) || identical(_exportedLibrariesState, CacheState.ERROR) || identical(_includedPartsState, CacheState.ERROR) || identical(_elementState, CacheState.ERROR) || identical(_publicNamespaceState, CacheState.ERROR) || identical(_clientServerState, CacheState.ERROR) || identical(_launchableState, CacheState.ERROR) || _resolutionState.hasErrorState();
+  bool hasErrorState() => super.hasErrorState() || identical(_scanErrorsState, CacheState.ERROR) || identical(_tokenStreamState, CacheState.ERROR) || identical(_sourceKindState, CacheState.ERROR) || identical(_parsedUnitState, CacheState.ERROR) || identical(_parseErrorsState, CacheState.ERROR) || identical(_importedLibrariesState, CacheState.ERROR) || identical(_exportedLibrariesState, CacheState.ERROR) || identical(_includedPartsState, CacheState.ERROR) || identical(_elementState, CacheState.ERROR) || identical(_publicNamespaceState, CacheState.ERROR) || identical(_clientServerState, CacheState.ERROR) || identical(_launchableState, CacheState.ERROR) || _resolutionState.hasErrorState();
 
   void writeOn(JavaStringBuilder builder) {
     builder.append("Dart: ");
     super.writeOn(builder);
+    builder.append("; tokenStream = ");
+    builder.append(_tokenStreamState);
+    builder.append("; scanErrors = ");
+    builder.append(_scanErrorsState);
     builder.append("; sourceKind = ");
     builder.append(_sourceKindState);
     builder.append("; parsedUnit = ");
     builder.append(_parsedUnitState);
     builder.append(" (");
     builder.append(_parsedUnitAccessed ? "T" : "F");
     builder.append("); parseErrors = ");
     builder.append(_parseErrorsState);
     builder.append("; exportedLibraries = ");
     builder.append(_exportedLibrariesState);
@@ skipping 283 matching lines @@
  * 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 information about an Angular application this source is
    * used in.
    */
-  static final DataDescriptor<AngularApplicationInfo> ANGULAR_APPLICATION = new DataDescriptor<AngularApplicationInfo>("HtmlEntry.ANGULAR_APPLICATION");
+  static final DataDescriptor<AngularApplication> ANGULAR_APPLICATION = new DataDescriptor<AngularApplication>("HtmlEntry.ANGULAR_APPLICATION");
 
   /**
    * The data descriptor representing the information about an Angular component this source is used
    * as template for.
    */
   static final DataDescriptor<AngularComponentElement> ANGULAR_COMPONENT = new DataDescriptor<AngularComponentElement>("HtmlEntry.ANGULAR_COMPONENT");
 
   /**
    * The data descriptor representing the information about an Angular application this source is
    * entry point for.
    */
-  static final DataDescriptor<AngularApplicationInfo> ANGULAR_ENTRY = new DataDescriptor<AngularApplicationInfo>("HtmlEntry.ANGULAR_ENTRY");
+  static final DataDescriptor<AngularApplication> ANGULAR_ENTRY = new DataDescriptor<AngularApplication>("HtmlEntry.ANGULAR_ENTRY");
 
   /**
    * The data descriptor representing the errors reported during Angular resolution.
    */
   static final DataDescriptor<List<AnalysisError>> ANGULAR_ERRORS = new DataDescriptor<List<AnalysisError>>("HtmlEntry.ANGULAR_ERRORS");
 
   /**
    * The data descriptor representing the HTML element.
    */
   static final DataDescriptor<HtmlElement> ELEMENT = new DataDescriptor<HtmlElement>("HtmlEntry.ELEMENT");
@@ skipping 116 matching lines @@
   HtmlElement _element;
 
   /**
    * The state of the [angularApplication].
    */
   CacheState _angularApplicationState = CacheState.VALID;
 
   /**
    * Information about the Angular Application this unit is used in.
    */
-  AngularApplicationInfo _angularApplication;
+  AngularApplication _angularApplication;
 
   /**
    * The state of the [angularEntry].
    */
-  CacheState _angularEntryState = CacheState.VALID;
+  CacheState _angularEntryState = CacheState.INVALID;
 
   /**
    * Information about the Angular Application this unit is entry point for.
    */
-  AngularApplicationInfo _angularEntry = null;
+  AngularApplication _angularEntry = null;
 
   /**
    * The state of the [angularComponent].
    */
   CacheState _angularComponentState = CacheState.VALID;
 
   /**
    * Information about the [AngularComponentElement] this unit is used as template for.
    */
   AngularComponentElement _angularComponent = null;
@@ skipping 146 matching lines @@
     _resolvedUnitState = CacheState.INVALID;
     _referencedLibraries = Source.EMPTY_ARRAY;
     _referencedLibrariesState = CacheState.INVALID;
     invalidateAllResolutionInformation();
   }
 
   /**
    * Invalidate all of the resolution information associated with the HTML file.
    */
   void invalidateAllResolutionInformation() {
+    _angularEntry = null;
+    _angularEntryState = CacheState.INVALID;
     _angularErrors = AnalysisError.NO_ERRORS;
     _angularErrorsState = CacheState.INVALID;
     _element = null;
     _elementState = CacheState.INVALID;
     _resolutionErrors = AnalysisError.NO_ERRORS;
     _resolutionErrorsState = CacheState.INVALID;
     _hints = AnalysisError.NO_ERRORS;
     _hintsState = CacheState.INVALID;
   }
 
@@ skipping 55 matching lines @@
     } 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.ANGULAR_APPLICATION)) {
-      _angularApplication = value as AngularApplicationInfo;
+      _angularApplication = value as AngularApplication;
       _angularApplicationState = CacheState.VALID;
     } else if (identical(descriptor, HtmlEntry.ANGULAR_COMPONENT)) {
       _angularComponent = value as AngularComponentElement;
       _angularComponentState = CacheState.VALID;
     } else if (identical(descriptor, HtmlEntry.ANGULAR_ENTRY)) {
-      _angularEntry = value as AngularApplicationInfo;
+      _angularEntry = value as AngularApplication;
       _angularEntryState = CacheState.VALID;
     } else if (identical(descriptor, HtmlEntry.ANGULAR_ERRORS)) {
       _angularErrors = value as List<AnalysisError>;
       _angularErrorsState = CacheState.VALID;
     } else if (identical(descriptor, HtmlEntry.ELEMENT)) {
       _element = value as HtmlElement;
       _elementState = CacheState.VALID;
     } else if (identical(descriptor, HtmlEntry.PARSE_ERRORS)) {
       _parseErrors = value as List<AnalysisError>;
       _parseErrorsState = CacheState.VALID;
@@ skipping 336 matching lines @@
     builder.append(_lineInfoState);
   }
 }
 
 /**
  * Implementation of the [AnalysisContentStatistics].
  */
 class AnalysisContentStatisticsImpl implements AnalysisContentStatistics {
   Map<String, AnalysisContentStatistics_CacheRow> _dataMap = new Map<String, AnalysisContentStatistics_CacheRow>();
 
+  List<Source> _sources = new List<Source>();
+
   Set<AnalysisException> _exceptions = new Set<AnalysisException>();
 
+  void addSource(Source source) {
+    _sources.add(source);
+  }
+
   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));
+  List<Source> get sources => new List.from(_sources);
+
+  void putCacheItem(DartEntry dartEntry, Source librarySource, DataDescriptor descriptor) {
+    putCacheItem3(dartEntry, descriptor, dartEntry.getState2(descriptor, librarySource));
   }
 
-  void putCacheItem2(DartEntry dartEntry, Source librarySource, DataDescriptor descriptor) {
-    putCacheItem3(dartEntry, descriptor, dartEntry.getState2(descriptor, librarySource));
+  void putCacheItem2(SourceEntry dartEntry, DataDescriptor descriptor) {
+    putCacheItem3(dartEntry, descriptor, dartEntry.getState(descriptor));
   }
 
   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);
@@ skipping 67 matching lines @@
    * 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.
    */
   AnalysisOptionsImpl _options = new AnalysisOptionsImpl();
 
   /**
+   * A cache of content used to override the default content of a source.
+   */
+  ContentCache _contentCache = new ContentCache();
+
+  /**
    * The source factory used to create the sources that can be analyzed in this context.
    */
   SourceFactory _sourceFactory;
 
   /**
    * A table mapping the sources known to the context to the information known about the source.
    */
   AnalysisCache _cache;
 
   /**
@@ skipping 35 matching lines @@
    * [cacheLock] before accessing this field.
    */
   IncrementalAnalysisCache _incrementalAnalysisCache;
 
   /**
    * The object used to manage the list of sources that need to be analyzed.
    */
   WorkManager _workManager = new WorkManager();
 
   /**
+   * The set of [AngularApplication] in this context.
+   */
+  Set<AngularApplication> _angularApplications = new Set();
+
+  /**
    * 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) {
     // This implementation assumes that the access to the cache does not need to be synchronized
     // because no other object can have access to this context while this method is being invoked.
@@ skipping 90 matching lines @@
       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;
-      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));
-        ListUtilities.addAll(errors, getDartVerificationData(source, source, dartEntry, DartEntry.VERIFICATION_ERRORS));
-        if (enableHints) {
-          ListUtilities.addAll(errors, getDartHintData(source, source, dartEntry, DartEntry.HINTS));
-        }
-      } else {
-        List<Source> libraries = getLibrariesContaining(source);
-        for (Source librarySource in libraries) {
-          ListUtilities.addAll(errors, getDartResolutionData(source, librarySource, dartEntry, DartEntry.RESOLUTION_ERRORS));
-          ListUtilities.addAll(errors, getDartVerificationData(source, librarySource, dartEntry, DartEntry.VERIFICATION_ERRORS));
+      try {
+        DartEntry dartEntry = sourceEntry;
+        ListUtilities.addAll(errors, getDartScanData(source, dartEntry, DartEntry.SCAN_ERRORS));
+        dartEntry = getReadableDartEntry(source);
+        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));
+          dartEntry = getReadableDartEntry(source);
+          ListUtilities.addAll(errors, getDartVerificationData(source, source, dartEntry, DartEntry.VERIFICATION_ERRORS));
           if (enableHints) {
-            ListUtilities.addAll(errors, getDartHintData(source, librarySource, dartEntry, DartEntry.HINTS));
+            dartEntry = getReadableDartEntry(source);
+            ListUtilities.addAll(errors, getDartHintData(source, source, dartEntry, DartEntry.HINTS));
+          }
+        } else {
+          List<Source> libraries = getLibrariesContaining(source);
+          for (Source librarySource in libraries) {
+            ListUtilities.addAll(errors, getDartResolutionData(source, librarySource, dartEntry, DartEntry.RESOLUTION_ERRORS));
+            dartEntry = getReadableDartEntry(source);
+            ListUtilities.addAll(errors, getDartVerificationData(source, librarySource, dartEntry, DartEntry.VERIFICATION_ERRORS));
+            if (enableHints) {
+              dartEntry = getReadableDartEntry(source);
+              ListUtilities.addAll(errors, getDartHintData(source, librarySource, dartEntry, DartEntry.HINTS));
+            }
           }
         }
+      } on ObsoleteSourceAnalysisException catch (exception) {
+        AnalysisEngine.instance.logger.logInformation3("Could not compute errors", exception);
       }
       if (errors.isEmpty) {
         return AnalysisError.NO_ERRORS;
       }
       return new List.from(errors);
     } else if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
-      return getHtmlResolutionData2(source, htmlEntry, HtmlEntry.RESOLUTION_ERRORS);
+      try {
+        return getHtmlResolutionData2(source, htmlEntry, HtmlEntry.RESOLUTION_ERRORS);
+      } on ObsoleteSourceAnalysisException catch (exception) {
+        AnalysisEngine.instance.logger.logInformation3("Could not compute errors", exception);
+      }
     }
     return AnalysisError.NO_ERRORS;
   }
 
   List<Source> computeExportedLibraries(Source source) => getDartDependencyData2(source, DartEntry.EXPORTED_LIBRARIES, Source.EMPTY_ARRAY);
 
   HtmlElement computeHtmlElement(Source source) => getHtmlResolutionData(source, HtmlEntry.ELEMENT, null);
 
   List<Source> computeImportedLibraries(Source source) => getDartDependencyData2(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, 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);
+    try {
+      if (sourceEntry is HtmlEntry) {
+        return getHtmlParseData(source, SourceEntry.LINE_INFO, null);
+      } else if (sourceEntry is DartEntry) {
+        return getDartScanData2(source, SourceEntry.LINE_INFO, null);
+      }
+    } on ObsoleteSourceAnalysisException catch (exception) {
+      AnalysisEngine.instance.logger.logInformation3("Could not compute ${SourceEntry.LINE_INFO.toString()}", exception);
     }
     return null;
   }
 
   ResolvableHtmlUnit computeResolvableAngularComponentHtmlUnit(Source source) {
     HtmlEntry htmlEntry = getReadableHtmlEntry(source);
     if (htmlEntry == null) {
       throw new AnalysisException.con1("computeResolvableAngularComponentHtmlUnit invoked for non-HTML file: ${source.fullName}");
     }
     htmlEntry = cacheHtmlResolutionData(source, htmlEntry, HtmlEntry.RESOLVED_UNIT);
@@ skipping 30 matching lines @@
     }
     htmlEntry = cacheHtmlParseData(source, htmlEntry, HtmlEntry.PARSED_UNIT);
     ht.HtmlUnit unit = htmlEntry.getValue(HtmlEntry.PARSED_UNIT);
     if (unit == null) {
       throw new AnalysisException.con1("Internal error: computeResolvableHtmlUnit could not parse ${source.fullName}");
     }
     // If the unit is ever modified by resolution then we will need to create a copy of it.
     return new ResolvableHtmlUnit(htmlEntry.modificationTime, unit);
   }
 
+  bool exists(Source source) {
+    if (source == null) {
+      return false;
+    }
+    if (_contentCache.getContents(source) != null) {
+      return true;
+    }
+    return source.exists();
+  }
+
   AnalysisContext extractContext(SourceContainer container) => extractContextInto(container, AnalysisEngine.instance.createAnalysisContext() as InternalAnalysisContext);
 
   InternalAnalysisContext extractContextInto(SourceContainer container, InternalAnalysisContext newContext) {
     List<Source> sourcesToRemove = new List<Source>();
     {
       // Move sources in the specified directory to the new context
       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;
 
+  CompilationUnitElement getCompilationUnitElement(Source unitSource, Source librarySource) {
+    LibraryElement libraryElement = getLibraryElement(librarySource);
+    if (libraryElement != null) {
+      // try defining unit
+      CompilationUnitElement definingUnit = libraryElement.definingCompilationUnit;
+      if (definingUnit.source == unitSource) {
+        return definingUnit;
+      }
+      // try parts
+      for (CompilationUnitElement partUnit in libraryElement.parts) {
+        if (partUnit.source == unitSource) {
+          return partUnit;
+        }
+      }
+    }
+    return null;
+  }
+
+  TimestampedData<String> getContents(Source source) {
+    String contents = _contentCache.getContents(source);
+    if (contents != null) {
+      return new TimestampedData<String>(_contentCache.getModificationStamp(source), contents);
+    }
+    return source.contents;
+  }
+
+  void getContents2(Source source, Source_ContentReceiver receiver) {
+    String contents = _contentCache.getContents(source);
+    if (contents != null) {
+      receiver.accept(contents, _contentCache.getModificationStamp(source));
+      return;
+    }
+    source.getContentsToReceiver(receiver);
+  }
+
   Element getElement(ElementLocation location) {
     // TODO(brianwilkerson) This should not be a "get" method.
     try {
       List<String> components = (location as ElementLocationImpl).components;
       Source librarySource = computeSourceFromEncoding(components[0]);
       ElementImpl element = computeLibraryElement(librarySource) as ElementImpl;
       for (int i = 1; i < components.length; i++) {
         if (element == null) {
           return null;
         }
@@ skipping 141 matching lines @@
   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;
   }
 
+  int getModificationStamp(Source source) {
+    int stamp = _contentCache.getModificationStamp(source);
+    if (stamp != null) {
+      return stamp;
+    }
+    return source.modificationStamp;
+  }
+
   Namespace getPublicNamespace(LibraryElement library) {
     // TODO(brianwilkerson) Rename this to not start with 'get'. Note that this is not part of the
     // API of the interface.
     Source source = library.definingCompilationUnit.source;
     DartEntry dartEntry = getReadableDartEntry(source);
     if (dartEntry == null) {
       return null;
     }
     Namespace namespace = null;
     if (identical(dartEntry.getValue(DartEntry.ELEMENT), library)) {
@@ skipping 113 matching lines @@
         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()) {
+        statistics.addSource(mapEntry.getKey());
         SourceEntry entry = mapEntry.getValue();
         if (entry is DartEntry) {
           Source source = mapEntry.getKey();
           DartEntry dartEntry = entry;
           SourceKind kind = dartEntry.getValue(DartEntry.SOURCE_KIND);
           // get library independent values
-          statistics.putCacheItem(dartEntry, DartEntry.PARSE_ERRORS);
-          statistics.putCacheItem(dartEntry, DartEntry.PARSED_UNIT);
-          statistics.putCacheItem(dartEntry, DartEntry.SOURCE_KIND);
-          statistics.putCacheItem(dartEntry, SourceEntry.LINE_INFO);
+          statistics.putCacheItem2(dartEntry, SourceEntry.LINE_INFO);
+          statistics.putCacheItem2(dartEntry, DartEntry.PARSE_ERRORS);
+          statistics.putCacheItem2(dartEntry, DartEntry.PARSED_UNIT);
+          statistics.putCacheItem2(dartEntry, DartEntry.SOURCE_KIND);
           if (identical(kind, SourceKind.LIBRARY)) {
-            statistics.putCacheItem(dartEntry, DartEntry.ELEMENT);
-            statistics.putCacheItem(dartEntry, DartEntry.EXPORTED_LIBRARIES);
-            statistics.putCacheItem(dartEntry, DartEntry.IMPORTED_LIBRARIES);
-            statistics.putCacheItem(dartEntry, DartEntry.INCLUDED_PARTS);
-            statistics.putCacheItem(dartEntry, DartEntry.IS_CLIENT);
-            statistics.putCacheItem(dartEntry, DartEntry.IS_LAUNCHABLE);
+            statistics.putCacheItem2(dartEntry, DartEntry.ELEMENT);
+            statistics.putCacheItem2(dartEntry, DartEntry.EXPORTED_LIBRARIES);
+            statistics.putCacheItem2(dartEntry, DartEntry.IMPORTED_LIBRARIES);
+            statistics.putCacheItem2(dartEntry, DartEntry.INCLUDED_PARTS);
+            statistics.putCacheItem2(dartEntry, DartEntry.IS_CLIENT);
+            statistics.putCacheItem2(dartEntry, DartEntry.IS_LAUNCHABLE);
           }
           // get library-specific values
           List<Source> librarySources = getLibrariesContaining(source);
           for (Source librarySource in librarySources) {
-            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);
+            statistics.putCacheItem(dartEntry, librarySource, DartEntry.HINTS);
+            statistics.putCacheItem(dartEntry, librarySource, DartEntry.RESOLUTION_ERRORS);
+            statistics.putCacheItem(dartEntry, librarySource, DartEntry.RESOLVED_UNIT);
+            statistics.putCacheItem(dartEntry, librarySource, DartEntry.VERIFICATION_ERRORS);
           }
+        } else if (entry is HtmlEntry) {
+          HtmlEntry htmlEntry = entry;
+          statistics.putCacheItem2(htmlEntry, SourceEntry.LINE_INFO);
+          statistics.putCacheItem2(htmlEntry, HtmlEntry.PARSE_ERRORS);
+          statistics.putCacheItem2(htmlEntry, HtmlEntry.PARSED_UNIT);
+          statistics.putCacheItem2(htmlEntry, HtmlEntry.RESOLUTION_ERRORS);
+          statistics.putCacheItem2(htmlEntry, HtmlEntry.RESOLVED_UNIT);
+          statistics.putCacheItem2(htmlEntry, HtmlEntry.HINTS);
         }
       }
     }
     return statistics;
   }
 
   TypeProvider get typeProvider {
     Source coreSource = sourceFactory.forUri(DartSdk.DART_CORE);
     return new TypeProviderImpl(computeLibraryElement(coreSource));
   }
 
+  TimestampedData<CompilationUnit> internalParseCompilationUnit(Source source) {
+    DartEntry dartEntry = getReadableDartEntry(source);
+    if (dartEntry == null) {
+      throw new AnalysisException.con1("internalParseCompilationUnit invoked for non-Dart file: ${source.fullName}");
+    }
+    dartEntry = cacheDartParseData(source, dartEntry, DartEntry.PARSED_UNIT);
+    CompilationUnit unit = dartEntry.anyParsedCompilationUnit;
+    if (unit == null) {
+      throw new AnalysisException.con2("internalParseCompilationUnit could not cache a parsed unit: ${source.fullName}", dartEntry.exception);
+    }
+    return new TimestampedData<CompilationUnit>(dartEntry.modificationTime, unit);
+  }
+
   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));
   }
 
+  TimestampedData<Token> internalScanTokenStream(Source source) {
+    DartEntry dartEntry = getReadableDartEntry(source);
+    if (dartEntry == null) {
+      throw new AnalysisException.con1("internalScanTokenStream invoked for non-Dart file: ${source.fullName}");
+    }
+    dartEntry = cacheDartScanData(source, dartEntry, DartEntry.TOKEN_STREAM);
+    return new TimestampedData<Token>(dartEntry.modificationTime, dartEntry.getValue(DartEntry.TOKEN_STREAM));
+  }
+
   bool isClientLibrary(Source librarySource) {
     SourceEntry sourceEntry = getReadableSourceEntry(librarySource);
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       return dartEntry.getValue(DartEntry.IS_CLIENT) && dartEntry.getValue(DartEntry.IS_LAUNCHABLE);
     }
     return false;
   }
 
   bool isServerLibrary(Source librarySource) {
@@ skipping 42 matching lines @@
     }
     String taskDescriptor = task.toString();
     if (_recentTasks.add(taskDescriptor)) {
       logInformation("Performing task: ${taskDescriptor}");
     } else {
       logInformation("*** Performing repeated task: ${taskDescriptor}");
     }
     int performStart = JavaSystem.currentTimeMillis();
     try {
       task.perform(_resultRecorder);
+    } on ObsoleteSourceAnalysisException catch (exception) {
+      AnalysisEngine.instance.logger.logInformation3("Could not perform analysis task: ${taskDescriptor}", exception);
     } 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) {
@@ skipping 79 matching lines @@
         for (int i = 0; i < count; i++) {
           _priorityOrder[i] = sources[i];
         }
       }
     }
   }
 
   void setChangedContents(Source source, String contents, int offset, int oldLength, int newLength) {
     {
       _recentTasks.clear();
-      String originalContents = _sourceFactory.setContents(source, contents);
+      String originalContents = _contentCache.setContents(source, contents);
       if (contents != null) {
         if (contents != originalContents) {
           if (_options.incremental) {
             _incrementalAnalysisCache = IncrementalAnalysisCache.update(_incrementalAnalysisCache, source, originalContents, contents, offset, oldLength, newLength, getReadableSourceEntry(source));
           }
           sourceChanged(source);
         }
       } else if (originalContents != null) {
         _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
         sourceChanged(source);
       }
     }
   }
 
   void setContents(Source source, String contents) {
     {
       _recentTasks.clear();
-      String originalContents = _sourceFactory.setContents(source, contents);
+      String originalContents = _contentCache.setContents(source, contents);
       if (contents != null) {
         if (contents != originalContents) {
           _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
           sourceChanged(source);
         }
       } else if (originalContents != null) {
         _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
         sourceChanged(source);
       }
     }
   }
 
   void set sourceFactory(SourceFactory factory) {
     {
       if (identical(_sourceFactory, factory)) {
         return;
       } else if (factory.context != null) {
         throw new IllegalStateException("Source factories cannot be shared between contexts");
       }
       if (_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;
-  }
-
   /**
    * Record the results produced by performing a [ResolveDartLibraryTask]. If the results were
    * computed from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   DartEntry recordResolveDartLibraryTaskResults(ResolveDartLibraryTask task) {
     LibraryResolver resolver = task.libraryResolver;
@@ skipping 28 matching lines @@
         if (allModificationTimesMatch(resolvedLibraries)) {
           Source htmlSource = sourceFactory.forUri(DartSdk.DART_HTML);
           RecordingErrorListener errorListener = resolver.errorListener;
           for (Library library in resolvedLibraries) {
             Source librarySource = library.librarySource;
             for (Source source in library.compilationUnitSources) {
               CompilationUnit unit = library.getAST(source);
               List<AnalysisError> errors = errorListener.getErrors2(source);
               LineInfo lineInfo = getLineInfo(source);
               DartEntry dartEntry = _cache.get(source) as DartEntry;
-              int sourceTime = source.modificationStamp;
+              int sourceTime = getModificationStamp(source);
               if (dartEntry.modificationTime != sourceTime) {
                 // The source has changed without the context being notified. Simulate notification.
                 sourceChanged(source);
                 dartEntry = getReadableDartEntry(source);
                 if (dartEntry == null) {
                   throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
                 }
               }
               DartEntryImpl dartCopy = dartEntry.writableCopy;
               if (thrownException == null) {
@@ skipping 23 matching lines @@
             }
           }
         } else {
           PrintStringWriter writer = new PrintStringWriter();
           writer.println("Library resolution results discarded for");
           for (Library library in resolvedLibraries) {
             for (Source source in library.compilationUnitSources) {
               DartEntry dartEntry = getReadableDartEntry(source);
               if (dartEntry != null) {
                 int resultTime = library.getModificationTime(source);
-                writer.println("  ${debuggingString(source)}; sourceTime = ${source.modificationStamp}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}");
+                writer.println("  ${debuggingString(source)}; sourceTime = ${getModificationStamp(source)}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}");
                 DartEntryImpl dartCopy = dartEntry.writableCopy;
                 if (thrownException == null || resultTime >= 0) {
                   //
                   // The analysis was performed on out-of-date sources. Mark the cache so that the
                   // sources will be re-analyzed using the up-to-date sources.
                   //
                   dartCopy.recordResolutionNotInProcess();
                 } else {
                   //
                   // We could not determine whether the sources were up-to-date or out-of-date. Mark
                   // the cache so that we won't attempt to re-analyze the sources until there's a
                   // good chance that we'll be able to do so without error.
                   //
                   dartCopy.recordResolutionError();
                   _cache.remove(source);
                 }
                 dartCopy.exception = thrownException;
                 _cache.put(source, dartCopy);
                 if (source == unitSource) {
                   unitEntry = dartCopy;
                 }
               } else {
-                writer.println("  ${debuggingString(source)}; sourceTime = ${source.modificationStamp}, no entry");
+                writer.println("  ${debuggingString(source)}; sourceTime = ${getModificationStamp(source)}, no entry");
               }
             }
           }
           logInformation(writer.toString());
         }
       }
     }
     if (thrownException != null) {
       throw thrownException;
     }
@@ skipping 47 matching lines @@
   bool allModificationTimesMatch(Set<Library> resolvedLibraries) {
     bool allTimesMatch = true;
     for (Library library in resolvedLibraries) {
       for (Source source in library.compilationUnitSources) {
         DartEntry dartEntry = getReadableDartEntry(source);
         if (dartEntry == null) {
           // This shouldn't be possible because we should never have performed the task if the
           // source didn't represent a Dart file, but check to be safe.
           throw new AnalysisException.con1("Internal error: attempting to resolve non-Dart file as a Dart file: ${source.fullName}");
         }
-        int sourceTime = source.modificationStamp;
+        int sourceTime = getModificationStamp(source);
         int resultTime = library.getModificationTime(source);
         if (sourceTime != resultTime) {
           // The source has changed without the context being notified. Simulate notification.
           sourceChanged(source);
           allTimesMatch = false;
         }
       }
     }
     return allTimesMatch;
   }
@@ skipping 58 matching lines @@
 
   /**
    * Given a source for a Dart file, return a cache entry in which the state of the data represented
    * by the given descriptor is either [CacheState#VALID] or [CacheState#ERROR]. This
    * method assumes that the data can be produced by parsing the source if it is not already cached.
    *
    * @param source the source representing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
-   * @throws AnalysisException if data could not be returned because the source could not be
-   *           resolved
+   * @throws AnalysisException if data could not be returned because the source could not be parsed
    */
   DartEntry cacheDartParseData(Source source, DartEntry dartEntry, DataDescriptor descriptor) {
     if (identical(descriptor, DartEntry.PARSED_UNIT)) {
       CompilationUnit unit = dartEntry.anyParsedCompilationUnit;
       if (unit != null) {
         return dartEntry;
       }
     }
     //
     // Check to see whether we already have the information being requested.
@@ skipping 35 matching lines @@
       //
       // TODO(brianwilkerson) As an optimization, if we already have the element model for the
       // library we can use ResolveDartUnitTask to produce the resolved AST structure much faster.
       dartEntry = new ResolveDartLibraryTask(this, unitSource, librarySource).perform(_resultRecorder) as DartEntry;
       state = (identical(descriptor, DartEntry.ELEMENT)) ? dartEntry.getState(descriptor) : dartEntry.getState2(descriptor, librarySource);
     }
     return dartEntry;
   }
 
   /**
+   * Given a source for a Dart file, return a cache entry in which the state of the data represented
+   * by the given descriptor is either [CacheState#VALID] or [CacheState#ERROR]. This
+   * method assumes that the data can be produced by scanning the source if it is not already
+   * cached.
+   *
+   * @param source the source representing the Dart file
+   * @param dartEntry the cache entry associated with the Dart file
+   * @param descriptor the descriptor representing the data to be returned
+   * @return a cache entry containing the required data
+   * @throws AnalysisException if data could not be returned because the source could not be scanned
+   */
+  DartEntry cacheDartScanData(Source source, DartEntry dartEntry, DataDescriptor descriptor) {
+    //
+    // Check to see whether we already have the information being requested.
+    //
+    CacheState state = dartEntry.getState(descriptor);
+    while (state != CacheState.ERROR && state != CacheState.VALID) {
+      //
+      // If not, compute the information. Unless the modification date of the source continues to
+      // change, this loop will eventually terminate.
+      //
+      // TODO(brianwilkerson) Convert this to get the contents from the cache. (I'm not sure how
+      // that would work in an asynchronous environment.)
+      try {
+        dartEntry = new ScanDartTask(this, source, getContents(source)).perform(_resultRecorder) as DartEntry;
+      } on AnalysisException catch (exception) {
+        throw exception;
+      } on JavaException catch (exception) {
+        throw new AnalysisException.con3(exception);
+      }
+      state = dartEntry.getState(descriptor);
+    }
+    return dartEntry;
+  }
+
+  /**
    * Given a source for a Dart file and the library that contains it, return a cache entry in which
    * the state of the data represented by the given descriptor is either [CacheState#VALID] or
    * [CacheState#ERROR]. This method assumes that the data can be produced by verifying the
    * source in the given library if the data is not already cached.
    *
    * @param unitSource the source representing the Dart file
    * @param librarySource the source representing the library containing the Dart file
    * @param dartEntry the cache entry associated with the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return a cache entry containing the required data
@@ skipping 127 matching lines @@
    * Create a source information object suitable for the given source. Return the source information
    * object that was created, or `null` if the source should not be tracked by this context.
    *
    * @param source the source for which an information object is being created
    * @return the source information object that was created
    */
   SourceEntry createSourceEntry(Source source) {
     String name = source.shortName;
     if (AnalysisEngine.isHtmlFileName(name)) {
       HtmlEntryImpl htmlEntry = new HtmlEntryImpl();
-      htmlEntry.modificationTime = source.modificationStamp;
+      htmlEntry.modificationTime = getModificationStamp(source);
       _cache.put(source, htmlEntry);
       return htmlEntry;
     } else {
       DartEntryImpl dartEntry = new DartEntryImpl();
-      dartEntry.modificationTime = source.modificationStamp;
+      dartEntry.modificationTime = getModificationStamp(source);
       _cache.put(source, dartEntry);
       return dartEntry;
     }
   }
 
   /**
    * Return a string with debugging information about the given source (the full name and
    * modification stamp of the source).
    *
    * @param source the source for which a debugging string is to be produced
    * @return debugging information about the given source
    */
-  String debuggingString(Source source) => "'${source.fullName}' [${source.modificationStamp}]";
+  String debuggingString(Source source) => "'${source.fullName}' [${getModificationStamp(source)}]";
 
   /**
    * Return an array containing all of the change notices that are waiting to be returned. If there
    * are no notices, then return either `null` or an empty array, depending on the value of
    * the argument.
    *
    * @param nullIfEmpty `true` if `null` should be returned when there are no notices
    * @return the change notices that are waiting to be returned
    */
   List<ChangeNotice> getChangeNotices(bool nullIfEmpty) {
@@ skipping 36 matching lines @@
    * @param descriptor the descriptor representing the data to be returned
    * @param defaultValue the value to be returned if the source is not a Dart file
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be parsed
    */
   Object getDartDependencyData2(Source source, DataDescriptor descriptor, Object defaultValue) {
     DartEntry dartEntry = getReadableDartEntry(source);
     if (dartEntry == null) {
       return defaultValue;
     }
-    return getDartDependencyData(source, dartEntry, descriptor);
+    try {
+      return getDartDependencyData(source, dartEntry, descriptor);
+    } on ObsoleteSourceAnalysisException catch (exception) {
+      AnalysisEngine.instance.logger.logInformation3("Could not compute ${descriptor.toString()}", exception);
+      return defaultValue;
+    }
   }
 
   /**
    * Given a source for a Dart file and the library that contains it, return the data represented by
    * the given descriptor that is associated with that source. This method assumes that the data can
    * be produced by generating hints for the library if it is not already cached.
    *
    * @param unitSource the source representing the Dart file
    * @param librarySource the source representing the library containing the Dart file
    * @param dartEntry the entry representing the Dart file
@@ skipping 39 matching lines @@
    * @param descriptor the descriptor representing the data to be returned
    * @param defaultValue the value to be returned if the source is not a Dart file
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be parsed
    */
   Object getDartParseData2(Source source, DataDescriptor descriptor, Object defaultValue) {
     DartEntry dartEntry = getReadableDartEntry(source);
     if (dartEntry == null) {
       return defaultValue;
     }
-    return getDartParseData(source, dartEntry, descriptor);
+    try {
+      return getDartParseData(source, dartEntry, descriptor);
+    } on ObsoleteSourceAnalysisException catch (exception) {
+      AnalysisEngine.instance.logger.logInformation3("Could not compute ${descriptor.toString()}", exception);
+      return defaultValue;
+    }
   }
 
   /**
    * Given a source for a Dart file and the library that contains it, return the data represented by
    * the given descriptor that is associated with that source. This method assumes that the data can
    * be produced by resolving the source in the context of the library if it is not already cached.
    *
    * @param unitSource the source representing the Dart file
    * @param librarySource the source representing the library containing the Dart file
    * @param dartEntry the entry representing the Dart file
@@ skipping 24 matching lines @@
    * @param defaultValue the value to be returned if the source is not a Dart file
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
    */
   Object getDartResolutionData2(Source unitSource, Source librarySource, DataDescriptor descriptor, Object defaultValue) {
     DartEntry dartEntry = getReadableDartEntry(unitSource);
     if (dartEntry == null) {
       return defaultValue;
     }
-    return getDartResolutionData(unitSource, librarySource, dartEntry, descriptor);
+    try {
+      return getDartResolutionData(unitSource, librarySource, dartEntry, descriptor);
+    } on ObsoleteSourceAnalysisException catch (exception) {
+      AnalysisEngine.instance.logger.logInformation3("Could not compute ${descriptor.toString()}", exception);
+      return defaultValue;
+    }
   }
 
   /**
+   * Given a source for a Dart file, return the data represented by the given descriptor that is
+   * associated with that source. This method assumes that the data can be produced by scanning the
+   * source if it is not already cached.
+   *
+   * @param source the source representing the Dart file
+   * @param dartEntry the cache entry associated with the Dart file
+   * @param descriptor the descriptor representing the data to be returned
+   * @return the requested data about the given source
+   * @throws AnalysisException if data could not be returned because the source could not be scanned
+   */
+  Object getDartScanData(Source source, DartEntry dartEntry, DataDescriptor descriptor) {
+    dartEntry = cacheDartScanData(source, dartEntry, descriptor);
+    return dartEntry.getValue(descriptor);
+  }
+
+  /**
+   * Given a source for a Dart file, return the data represented by the given descriptor that is
+   * associated with that source, or the given default value if the source is not a Dart file. This
+   * method assumes that the data can be produced by scanning the source if it is not already
+   * cached.
+   *
+   * @param source the source representing the Dart file
+   * @param descriptor the descriptor representing the data to be returned
+   * @param defaultValue the value to be returned if the source is not a Dart file
+   * @return the requested data about the given source
+   * @throws AnalysisException if data could not be returned because the source could not be scanned
+   */
+  Object getDartScanData2(Source source, DataDescriptor descriptor, Object defaultValue) {
+    DartEntry dartEntry = getReadableDartEntry(source);
+    if (dartEntry == null) {
+      return defaultValue;
+    }
+    try {
+      return getDartScanData(source, dartEntry, descriptor);
+    } on ObsoleteSourceAnalysisException catch (exception) {
+      AnalysisEngine.instance.logger.logInformation3("Could not compute ${descriptor.toString()}", exception);
+      return defaultValue;
+    }
+  }
+
+  /**
    * Given a source for a Dart file and the library that contains it, return the data represented by
    * the given descriptor that is associated with that source. This method assumes that the data can
    * be produced by verifying the source within the given library if it is not already cached.
    *
    * @param unitSource the source representing the Dart file
    * @param librarySource the source representing the library containing the Dart file
    * @param dartEntry the entry representing the Dart file
    * @param descriptor the descriptor representing the data to be returned
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be
@@ skipping 39 matching lines @@
    * @param defaultValue the value to be returned if the source is not an HTML file
    * @return the requested data about the given source
    * @throws AnalysisException if data could not be returned because the source could not be
    *           resolved
    */
   Object getHtmlResolutionData(Source source, DataDescriptor descriptor, Object defaultValue) {
     HtmlEntry htmlEntry = getReadableHtmlEntry(source);
     if (htmlEntry == null) {
       return defaultValue;
     }
-    return getHtmlResolutionData2(source, htmlEntry, descriptor);
+    try {
+      return getHtmlResolutionData2(source, htmlEntry, descriptor);
+    } on ObsoleteSourceAnalysisException catch (exception) {
+      AnalysisEngine.instance.logger.logInformation3("Could not compute ${descriptor.toString()}", exception);
+      return defaultValue;
+    }
   }
 
   /**
    * Given a source for an HTML file, return the data represented by the given descriptor that is
    * associated with that source. This method assumes that the data can be produced by resolving the
    * source if it is not already cached.
    *
    * @param source the source representing the HTML file
    * @param htmlEntry the entry representing the HTML file
    * @param descriptor the descriptor representing the data to be returned
@@ skipping 11 matching lines @@
 
   /**
    * Look through the cache for a task that needs to be performed. Return the task that was found,
    * or `null` if there is no more work to be done.
    *
    * @return the next task that needs to be performed
    */
   AnalysisTask get nextAnalysisTask {
     {
       bool hintsEnabled = _options.hint;
+      bool sdkErrorsEnabled = _options.generateSdkErrors;
       //
       // Look for incremental analysis
       //
       if (_incrementalAnalysisCache != null && _incrementalAnalysisCache.hasWork()) {
         AnalysisTask task = new IncrementalAnalysisTask(this, _incrementalAnalysisCache);
         _incrementalAnalysisCache = null;
         return task;
       }
       //
       // Look for a priority source that needs to be analyzed.
       //
       for (Source source in _priorityOrder) {
-        AnalysisTask task = getNextAnalysisTask2(source, _cache.get(source), true, hintsEnabled);
+        AnalysisTask task = getNextAnalysisTask2(source, _cache.get(source), true, hintsEnabled, sdkErrorsEnabled);
         if (task != null) {
           return task;
         }
       }
       //
       // Look for a non-priority source that needs to be analyzed.
       //
       Source source = _workManager.nextSource;
       while (source != null) {
-        AnalysisTask task = getNextAnalysisTask2(source, _cache.get(source), false, hintsEnabled);
+        AnalysisTask task = getNextAnalysisTask2(source, _cache.get(source), false, hintsEnabled, sdkErrorsEnabled);
         if (task != null) {
           return task;
         }
         _workManager.remove(source);
         source = _workManager.nextSource;
       }
       //      //
       //      // Look for a non-priority source that needs to be analyzed and was missed by the loop above.
       //      //
       //      for (Map.Entry<Source, SourceEntry> entry : cache.entrySet()) {
@@ skipping 12 matching lines @@
    * Look at the given source to see whether a task needs to be performed related to it. Return the
    * task that should be performed, or `null` if there is no more work to be done for the
    * source.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @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
+   * @param sdkErrorsEnabled `true` if errors, warnings and hints should be generated for
+   *          sources in the SDK
    * @return the next task that needs to be performed for the given source
    */
-  AnalysisTask getNextAnalysisTask2(Source source, SourceEntry sourceEntry, bool isPriority, bool hintsEnabled) {
+  AnalysisTask getNextAnalysisTask2(Source source, SourceEntry sourceEntry, bool isPriority, bool hintsEnabled, bool sdkErrorsEnabled) {
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
+      CacheState scanErrorsState = dartEntry.getState(DartEntry.SCAN_ERRORS);
+      if (identical(scanErrorsState, CacheState.INVALID) || (isPriority && identical(scanErrorsState, CacheState.FLUSHED))) {
+        // TODO(brianwilkerson) Convert this to get the contents from the cache or to asynchronously
+        // request the contents if they are not in the cache.
+        try {
+          DartEntryImpl dartCopy = dartEntry.writableCopy;
+          dartCopy.setState(DartEntry.SCAN_ERRORS, CacheState.IN_PROCESS);
+          _cache.put(source, dartCopy);
+          return new ScanDartTask(this, source, getContents(source));
+        } on JavaException catch (exception) {
+          DartEntryImpl dartCopy = dartEntry.writableCopy;
+          dartCopy.recordScanError();
+          dartCopy.exception = new AnalysisException.con3(exception);
+          _cache.put(source, dartCopy);
+        }
+      }
       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) {
@@ skipping 29 matching lines @@
             // then there won't be any elements in the element model that we can use to resolve it.
             //
             //LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
             //if (libraryElement != null) {
             DartEntryImpl dartCopy = dartEntry.writableCopy;
             dartCopy.setState2(DartEntry.RESOLVED_UNIT, librarySource, CacheState.IN_PROCESS);
             _cache.put(source, dartCopy);
             //return new ResolveDartUnitTask(this, source, libraryElement);
             return new ResolveDartLibraryTask(this, source, librarySource);
           }
-          CacheState verificationErrorsState = dartEntry.getState2(DartEntry.VERIFICATION_ERRORS, librarySource);
-          if (identical(verificationErrorsState, CacheState.INVALID) || (isPriority && identical(verificationErrorsState, CacheState.FLUSHED))) {
-            LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
-            if (libraryElement != null) {
-              DartEntryImpl dartCopy = dartEntry.writableCopy;
-              dartCopy.setState2(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.IN_PROCESS);
-              _cache.put(source, dartCopy);
-              return new GenerateDartErrorsTask(this, source, libraryElement);
-            }
-          }
-          if (hintsEnabled) {
-            CacheState hintsState = dartEntry.getState2(DartEntry.HINTS, librarySource);
-            if (identical(hintsState, CacheState.INVALID) || (isPriority && identical(hintsState, CacheState.FLUSHED))) {
+          if (sdkErrorsEnabled || !source.isInSystemLibrary) {
+            CacheState verificationErrorsState = dartEntry.getState2(DartEntry.VERIFICATION_ERRORS, librarySource);
+            if (identical(verificationErrorsState, CacheState.INVALID) || (isPriority && identical(verificationErrorsState, CacheState.FLUSHED))) {
               LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
               if (libraryElement != null) {
                 DartEntryImpl dartCopy = dartEntry.writableCopy;
-                dartCopy.setState2(DartEntry.HINTS, librarySource, CacheState.IN_PROCESS);
+                dartCopy.setState2(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.IN_PROCESS);
                 _cache.put(source, dartCopy);
-                return new GenerateDartHintsTask(this, libraryElement);
+                return new GenerateDartErrorsTask(this, source, libraryElement);
+              }
+            }
+            if (hintsEnabled) {
+              CacheState hintsState = dartEntry.getState2(DartEntry.HINTS, librarySource);
+              if (identical(hintsState, CacheState.INVALID) || (isPriority && identical(hintsState, CacheState.FLUSHED))) {
+                LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
+                if (libraryElement != null) {
+                  DartEntryImpl dartCopy = dartEntry.writableCopy;
+                  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;
       CacheState parseErrorsState = htmlEntry.getState(HtmlEntry.PARSE_ERRORS);
       if (identical(parseErrorsState, CacheState.INVALID) || (isPriority && identical(parseErrorsState, CacheState.FLUSHED))) {
         HtmlEntryImpl dartCopy = htmlEntry.writableCopy;
@@ skipping 10 matching lines @@
           return new ParseHtmlTask(this, source);
         }
       }
       CacheState resolvedUnitState = htmlEntry.getState(HtmlEntry.RESOLVED_UNIT);
       if (identical(resolvedUnitState, CacheState.INVALID) || (isPriority && identical(resolvedUnitState, CacheState.FLUSHED))) {
         HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
         htmlCopy.setState(HtmlEntry.RESOLVED_UNIT, CacheState.IN_PROCESS);
         _cache.put(source, htmlCopy);
         return new ResolveHtmlTask(this, source);
       }
+      // Angular support
       if (_options.analyzeAngular) {
+        // try to resolve as an Angular entry point
+        CacheState angularEntryState = htmlEntry.getState(HtmlEntry.ANGULAR_ENTRY);
+        if (identical(angularEntryState, CacheState.INVALID)) {
+          HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
+          htmlCopy.setState(HtmlEntry.ANGULAR_ENTRY, CacheState.IN_PROCESS);
+          _cache.put(source, htmlCopy);
+          return new ResolveAngularEntryHtmlTask(this, source);
+        }
+        // try to resolve as an Angular application part
         CacheState angularErrorsState = htmlEntry.getState(HtmlEntry.ANGULAR_ERRORS);
         if (identical(angularErrorsState, CacheState.INVALID)) {
-          AngularApplicationInfo entryInfo = htmlEntry.getValue(HtmlEntry.ANGULAR_ENTRY);
-          if (entryInfo != null) {
-            HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-            htmlCopy.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.IN_PROCESS);
-            _cache.put(source, htmlCopy);
-            return new ResolveAngularEntryHtmlTask(this, source, entryInfo);
-          }
-          AngularApplicationInfo applicationInfo = htmlEntry.getValue(HtmlEntry.ANGULAR_APPLICATION);
-          if (applicationInfo != null) {
-            AngularComponentElement component = htmlEntry.getValue(HtmlEntry.ANGULAR_COMPONENT);
-            if (component != null) {
-              HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-              htmlCopy.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.IN_PROCESS);
-              _cache.put(source, htmlCopy);
-              return new ResolveAngularComponentTemplateTask(this, source, component, applicationInfo);
-            }
-          }
+          AngularApplication application = htmlEntry.getValue(HtmlEntry.ANGULAR_APPLICATION);
+          // try to resolve as an Angular template
+          AngularComponentElement component = htmlEntry.getValue(HtmlEntry.ANGULAR_COMPONENT);
           HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-          htmlCopy.setValue(HtmlEntry.ANGULAR_ERRORS, AnalysisError.NO_ERRORS);
+          htmlCopy.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.IN_PROCESS);
           _cache.put(source, htmlCopy);
+          return new ResolveAngularComponentTemplateTask(this, source, component, application);
         }
       }
     }
     return null;
   }
 
   /**
    * Return a change notice for the given source, creating one if one does not already exist.
    *
    * @param source the source for which changes are being reported
@@ skipping 94 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
    * @param sources the set to which sources should be added
    */
   void getSourcesNeedingProcessing2(Source source, SourceEntry sourceEntry, bool isPriority, bool hintsEnabled, Set<Source> sources) {
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
+      CacheState scanErrorsState = dartEntry.getState(DartEntry.SCAN_ERRORS);
+      if (identical(scanErrorsState, CacheState.INVALID) || (isPriority && identical(scanErrorsState, CacheState.FLUSHED))) {
+        sources.add(source);
+        return;
+      }
       CacheState parseErrorsState = dartEntry.getState(DartEntry.PARSE_ERRORS);
       if (identical(parseErrorsState, CacheState.INVALID) || (isPriority && identical(parseErrorsState, CacheState.FLUSHED))) {
         sources.add(source);
         return;
       }
       if (isPriority) {
         CompilationUnit parseUnit = dartEntry.anyParsedCompilationUnit;
         if (parseUnit == null) {
           sources.add(source);
           return;
@@ skipping 40 matching lines @@
       CacheState parsedUnitState = htmlEntry.getState(HtmlEntry.PARSED_UNIT);
       if (identical(parsedUnitState, CacheState.INVALID) || (isPriority && identical(parsedUnitState, CacheState.FLUSHED))) {
         sources.add(source);
         return;
       }
       CacheState resolvedUnitState = htmlEntry.getState(HtmlEntry.RESOLVED_UNIT);
       if (identical(resolvedUnitState, CacheState.INVALID) || (isPriority && identical(resolvedUnitState, CacheState.FLUSHED))) {
         sources.add(source);
         return;
       }
+      // Angular
       if (_options.analyzeAngular) {
         CacheState angularErrorsState = htmlEntry.getState(HtmlEntry.ANGULAR_ERRORS);
         if (identical(angularErrorsState, CacheState.INVALID)) {
-          AngularApplicationInfo entryInfo = htmlEntry.getValue(HtmlEntry.ANGULAR_ENTRY);
+          AngularApplication entryInfo = htmlEntry.getValue(HtmlEntry.ANGULAR_ENTRY);
           if (entryInfo != null) {
             sources.add(source);
             return;
           }
-          AngularApplicationInfo applicationInfo = htmlEntry.getValue(HtmlEntry.ANGULAR_APPLICATION);
+          AngularApplication applicationInfo = htmlEntry.getValue(HtmlEntry.ANGULAR_APPLICATION);
           if (applicationInfo != null) {
             AngularComponentElement component = htmlEntry.getValue(HtmlEntry.ANGULAR_COMPONENT);
             if (component != null) {
               sources.add(source);
               return;
             }
           }
         }
       }
     }
@@ skipping 17 matching lines @@
         removeFromParts(source, dartEntry);
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         dartCopy.invalidateAllResolutionInformation();
         mapEntry.setValue(dartCopy);
         _workManager.add(source, SourcePriority.UNKNOWN);
       }
     }
   }
 
   /**
+   * In response to a change to Angular entry point [HtmlElement], invalidate any results that
+   * depend on it.
+   *
+   * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
+   *
+   * <b>Note:</b> Any cache entries that were accessed before this method was invoked must be
+   * re-accessed after this method returns.
+   *
+   * @param entryCopy the [HtmlEntryImpl] of the (maybe) Angular entry point being invalidated
+   */
+  void invalidateAngularResolution(HtmlEntryImpl entryCopy) {
+    AngularApplication application = entryCopy.getValue(HtmlEntry.ANGULAR_ENTRY);
+    if (application == null) {
+      return;
+    }
+    _angularApplications.remove(application);
+    // invalidate Entry
+    entryCopy.setState(HtmlEntry.ANGULAR_ENTRY, CacheState.INVALID);
+    // reset HTML sources
+    List<AngularElement> oldAngularElements = application.elements;
+    for (AngularElement angularElement in oldAngularElements) {
+      if (angularElement is AngularHasTemplateElement) {
+        AngularHasTemplateElement hasTemplate = angularElement;
+        Source templateSource = hasTemplate.templateSource;
+        if (templateSource != null) {
+          HtmlEntry htmlEntry = getReadableHtmlEntry(templateSource);
+          HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
+          htmlCopy.setValue(HtmlEntry.ANGULAR_APPLICATION, null);
+          htmlCopy.setValue(HtmlEntry.ANGULAR_COMPONENT, null);
+          htmlCopy.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.INVALID);
+          _cache.put(templateSource, htmlCopy);
+          _workManager.add(templateSource, SourcePriority.HTML);
+        }
+      }
+    }
+    // reset Dart sources
+    List<Source> oldElementSources = application.elementSources;
+    for (Source elementSource in oldElementSources) {
+      DartEntry dartEntry = getReadableDartEntry(elementSource);
+      DartEntryImpl dartCopy = dartEntry.writableCopy;
+      dartCopy.setValue(DartEntry.ANGULAR_ERRORS, AnalysisError.NO_ERRORS);
+      _cache.put(elementSource, dartCopy);
+      // notify about (disappeared) Angular errors
+      ChangeNoticeImpl notice = getNotice(elementSource);
+      notice.setErrors(dartCopy.allErrors, dartEntry.getValue(SourceEntry.LINE_INFO));
+    }
+  }
+
+  /**
    * In response to a change to at least one of the compilation units in the given library,
    * invalidate any results that are dependent on the result of resolving that library.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * <b>Note:</b> Any cache entries that were accessed before this method was invoked must be
    * re-accessed after this method returns.
    *
    * @param librarySource the source of the library being invalidated
    * @param writer the writer to which debugging information should be written
@@ skipping 23 matching lines @@
             _workManager.add(librarySource, SourcePriority.NORMAL_PART);
           }
           partCopy.invalidateAllResolutionInformation();
           _cache.put(partSource, partCopy);
           if (writer != null) {
             writer.println("  Invalidated part source: ${debuggingString(partSource)} (previously modified at ${oldTime})");
           }
         }
       }
     }
+    // invalidate Angular applications
+    List<AngularApplication> angularApplicationsCopy = [];
+    for (AngularApplication application in angularApplicationsCopy) {
+      if (application.dependsOn(librarySource)) {
+        Source entryPointSource = application.entryPoint;
+        HtmlEntry entry = getReadableHtmlEntry(entryPointSource);
+        HtmlEntryImpl entryCopy = entry.writableCopy;
+        invalidateAngularResolution(entryCopy);
+        _cache.put(entryPointSource, entryCopy);
+        _workManager.add(entryPointSource, SourcePriority.HTML);
+      }
+    }
   }
 
   /**
    * Return `true` if this library is, or depends on, dart:html.
    *
    * @param library the library being tested
    * @param visitedLibraries a collection of the libraries that have been visited, used to prevent
    *          infinite recursion
    * @return `true` if this library is, or depends on, dart:html
    */
@@ skipping 35 matching lines @@
    */
   void logInformation2(String message, Exception exception) {
     if (exception == null) {
       AnalysisEngine.instance.logger.logInformation(message);
     } else {
       AnalysisEngine.instance.logger.logInformation3(message, exception);
     }
   }
 
   /**
-   * Updates [HtmlEntry]s that correspond to the previously known and new Angular components.
-   *
-   * @param library the [Library] that was resolved
-   * @param dartCopy the [DartEntryImpl] to record new Angular components
+   * Updates [HtmlEntry]s that correspond to the previously known and new Angular application
+   * information.
    */
-  void recordAngularComponents(HtmlEntryImpl entry, AngularApplicationInfo app) {
-    if (!_options.analyzeAngular) {
-      return;
-    }
-    // reset old Angular errors
-    AngularApplicationInfo oldApp = entry.getValue(HtmlEntry.ANGULAR_ENTRY);
-    if (oldApp != null) {
-      List<AngularElement> oldAngularElements = oldApp.elements;
-      for (AngularElement angularElement in oldAngularElements) {
-        if (angularElement is AngularComponentElement) {
-          AngularComponentElement component = angularElement;
-          Source templateSource = component.templateSource;
+  void recordAngularEntryPoint(HtmlEntryImpl entry, ResolveAngularEntryHtmlTask task) {
+    AngularApplication application = task.application;
+    if (application != null) {
+      _angularApplications.add(application);
+      // if this is an entry point, then we already resolved it
+      entry.setValue(HtmlEntry.ANGULAR_ERRORS, task.entryErrors);
+      // schedule HTML templates analysis
+      List<AngularElement> newAngularElements = application.elements;
+      for (AngularElement angularElement in newAngularElements) {
+        if (angularElement is AngularHasTemplateElement) {
+          AngularHasTemplateElement hasTemplate = angularElement;
+          Source templateSource = hasTemplate.templateSource;
           if (templateSource != null) {
             HtmlEntry htmlEntry = getReadableHtmlEntry(templateSource);
             HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-            htmlCopy.setValue(HtmlEntry.ANGULAR_APPLICATION, null);
-            htmlCopy.setValue(HtmlEntry.ANGULAR_COMPONENT, null);
-            htmlCopy.setValue(HtmlEntry.ANGULAR_ERRORS, AnalysisError.NO_ERRORS);
-            _cache.put(templateSource, htmlCopy);
-            // notify about (disappeared) HTML errors
-            ChangeNoticeImpl notice = getNotice(templateSource);
-            notice.setErrors(htmlCopy.allErrors, computeLineInfo(templateSource));
-          }
-        }
-      }
-    }
-    // prepare for new Angular analysis
-    if (app != null) {
-      List<AngularElement> newAngularElements = app.elements;
-      for (AngularElement angularElement in newAngularElements) {
-        if (angularElement is AngularComponentElement) {
-          AngularComponentElement component = angularElement;
-          Source templateSource = component.templateSource;
-          if (templateSource != null) {
-            HtmlEntry htmlEntry = getReadableHtmlEntry(templateSource);
-            HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-            htmlCopy.setValue(HtmlEntry.ANGULAR_APPLICATION, app);
-            htmlCopy.setValue(HtmlEntry.ANGULAR_COMPONENT, component);
+            htmlCopy.setValue(HtmlEntry.ANGULAR_APPLICATION, application);
+            if (hasTemplate is AngularComponentElement) {
+              AngularComponentElement component = hasTemplate;
+              htmlCopy.setValue(HtmlEntry.ANGULAR_COMPONENT, component);
+            }
             htmlCopy.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.INVALID);
             _cache.put(templateSource, htmlCopy);
             _workManager.add(templateSource, SourcePriority.HTML);
           }
         }
       }
+      // update Dart sources errors
+      List<Source> newElementSources = application.elementSources;
+      for (Source elementSource in newElementSources) {
+        DartEntry dartEntry = getReadableDartEntry(elementSource);
+        DartEntryImpl dartCopy = dartEntry.writableCopy;
+        dartCopy.setValue(DartEntry.ANGULAR_ERRORS, task.getErrors(elementSource));
+        _cache.put(elementSource, dartCopy);
+        // notify about Dart errors
+        ChangeNoticeImpl notice = getNotice(elementSource);
+        notice.setErrors(dartCopy.allErrors, computeLineInfo(elementSource));
+      }
     }
-    // remember Angular application
-    entry.setValue(HtmlEntry.ANGULAR_ENTRY, app);
-    entry.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.INVALID);
+    // remember Angular entry point
+    entry.setValue(HtmlEntry.ANGULAR_ENTRY, application);
   }
 
   /**
    * Given a cache entry and a library element, record the library element and other information
    * gleaned from the element in the cache entry.
    *
    * @param dartEntry the original cache entry from which the copy was made
    * @param dartCopy the cache entry in which data is to be recorded
    * @param library the library element used to record information
    * @param librarySource the source for the library used to record information
@@ skipping 32 matching lines @@
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   DartEntry recordGenerateDartErrorsTask(GenerateDartErrorsTask task) {
     Source source = task.source;
     Source librarySource = task.libraryElement.source;
     AnalysisException thrownException = task.exception;
     DartEntry dartEntry = null;
     {
       SourceEntry sourceEntry = _cache.get(source);
-      if (sourceEntry is! DartEntry) {
+      if (sourceEntry == null) {
+        throw new ObsoleteSourceAnalysisException(source);
+      } else if (sourceEntry is! DartEntry) {
         // This shouldn't be possible because we should never have performed the task if the source
         // didn't represent a Dart file, but check to be safe.
         throw new AnalysisException.con1("Internal error: attempting to verify non-Dart file as a Dart file: ${source.fullName}");
       }
       dartEntry = sourceEntry as DartEntry;
-      int sourceTime = source.modificationStamp;
+      int sourceTime = getModificationStamp(source);
       int resultTime = task.modificationTime;
       if (sourceTime == resultTime) {
         if (dartEntry.modificationTime != sourceTime) {
           // The source has changed without the context being notified. Simulate notification.
           sourceChanged(source);
           dartEntry = getReadableDartEntry(source);
           if (dartEntry == null) {
             throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
           }
         }
@@ skipping 52 matching lines @@
   DartEntry recordGenerateDartHintsTask(GenerateDartHintsTask task) {
     Source librarySource = task.libraryElement.source;
     AnalysisException thrownException = task.exception;
     DartEntry libraryEntry = null;
     Map<Source, TimestampedData<List<AnalysisError>>> hintMap = task.hintMap;
     if (hintMap == null) {
       {
         // We don't have any information about which sources to mark as invalid other than the library
         // source.
         SourceEntry sourceEntry = _cache.get(librarySource);
-        if (sourceEntry is! DartEntry) {
+        if (sourceEntry == null) {
+          throw new ObsoleteSourceAnalysisException(librarySource);
+        } else if (sourceEntry is! DartEntry) {
           // This shouldn't be possible because we should never have performed the task if the source
           // didn't represent a Dart file, but check to be safe.
           throw new AnalysisException.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;
         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();
       {
         SourceEntry sourceEntry = _cache.get(unitSource);
         if (sourceEntry is! DartEntry) {
           // This shouldn't be possible because we should never have performed the task if the source
           // didn't represent a Dart file, but check to be safe.
           throw new AnalysisException.con1("Internal error: attempting to parse non-Dart file as a Dart file: ${unitSource.fullName}");
         }
         DartEntry dartEntry = sourceEntry as DartEntry;
         if (unitSource == librarySource) {
           libraryEntry = dartEntry;
         }
-        int sourceTime = unitSource.modificationStamp;
+        int sourceTime = getModificationStamp(unitSource);
         int resultTime = results.modificationTime;
         if (sourceTime == resultTime) {
           if (dartEntry.modificationTime != sourceTime) {
             // The source has changed without the context being notified. Simulate notification.
             sourceChanged(unitSource);
             dartEntry = getReadableDartEntry(unitSource);
             if (dartEntry == null) {
               throw new AnalysisException.con1("A Dart file became a non-Dart file: ${unitSource.fullName}");
             }
           }
@@ skipping 70 matching lines @@
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   DartEntry recordParseDartTaskResults(ParseDartTask task) {
     Source source = task.source;
     AnalysisException thrownException = task.exception;
     DartEntry dartEntry = null;
     {
       SourceEntry sourceEntry = _cache.get(source);
-      if (sourceEntry is! DartEntry) {
+      if (sourceEntry == null) {
+        throw new ObsoleteSourceAnalysisException(source);
+      } else if (sourceEntry is! DartEntry) {
         // This shouldn't be possible because we should never have performed the task if the source
         // didn't represent a Dart file, but check to be safe.
         throw new AnalysisException.con1("Internal error: attempting to parse non-Dart file as a Dart file: ${source.fullName}");
       }
       dartEntry = sourceEntry as DartEntry;
-      int sourceTime = source.modificationStamp;
+      int sourceTime = getModificationStamp(source);
       int resultTime = task.modificationTime;
       if (sourceTime == resultTime) {
         if (dartEntry.modificationTime != sourceTime) {
           // The source has changed without the context being notified. Simulate notification.
           sourceChanged(source);
           dartEntry = getReadableDartEntry(source);
           if (dartEntry == null) {
             throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
           }
         }
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         if (thrownException == null) {
-          LineInfo lineInfo = task.lineInfo;
-          dartCopy.setValue(SourceEntry.LINE_INFO, lineInfo);
           if (task.hasPartOfDirective() && !task.hasLibraryDirective()) {
             dartCopy.setValue(DartEntry.SOURCE_KIND, SourceKind.PART);
+            dartCopy.removeContainingLibrary(source);
             _workManager.add(source, SourcePriority.NORMAL_PART);
           } else {
             dartCopy.setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY);
             dartCopy.containingLibrary = source;
             _workManager.add(source, SourcePriority.LIBRARY);
           }
           dartCopy.setValue(DartEntry.PARSED_UNIT, task.compilationUnit);
           dartCopy.setValue(DartEntry.PARSE_ERRORS, task.errors);
           _cache.storedAst(source);
           ChangeNoticeImpl notice = getNotice(source);
-          notice.setErrors(dartEntry.allErrors, lineInfo);
+          notice.setErrors(dartCopy.allErrors, dartCopy.getValue(SourceEntry.LINE_INFO));
           // Verify that the incrementally parsed and resolved unit in the incremental cache
           // is structurally equivalent to the fully parsed unit
           _incrementalAnalysisCache = IncrementalAnalysisCache.verifyStructure(_incrementalAnalysisCache, source, task.compilationUnit);
         } else {
           removeFromParts(source, dartEntry);
           dartCopy.recordParseError();
           _cache.removedAst(source);
         }
         dartCopy.exception = thrownException;
         _cache.put(source, dartCopy);
@@ skipping 38 matching lines @@
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   HtmlEntry recordParseHtmlTaskResults(ParseHtmlTask task) {
     Source source = task.source;
     AnalysisException thrownException = task.exception;
     HtmlEntry htmlEntry = null;
     {
       SourceEntry sourceEntry = _cache.get(source);
-      if (sourceEntry is! HtmlEntry) {
+      if (sourceEntry == null) {
+        throw new ObsoleteSourceAnalysisException(source);
+      } else if (sourceEntry is! HtmlEntry) {
         // This shouldn't be possible because we should never have performed the task if the source
         // didn't represent an HTML file, but check to be safe.
         throw new AnalysisException.con1("Internal error: attempting to parse non-HTML file as a HTML file: ${source.fullName}");
       }
       htmlEntry = sourceEntry as HtmlEntry;
-      int sourceTime = source.modificationStamp;
+      int sourceTime = getModificationStamp(source);
       int resultTime = task.modificationTime;
       if (sourceTime == resultTime) {
         if (htmlEntry.modificationTime != sourceTime) {
           // The source has changed without the context being notified. Simulate notification.
           sourceChanged(source);
           htmlEntry = getReadableHtmlEntry(source);
           if (htmlEntry == null) {
             throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
           }
         }
         HtmlEntryImpl htmlCopy = (sourceEntry as HtmlEntry).writableCopy;
         if (thrownException == null) {
           LineInfo lineInfo = task.lineInfo;
           ht.HtmlUnit unit = task.htmlUnit;
           htmlCopy.setValue(SourceEntry.LINE_INFO, lineInfo);
           htmlCopy.setValue(HtmlEntry.PARSED_UNIT, unit);
           htmlCopy.setValue(HtmlEntry.PARSE_ERRORS, task.errors);
           htmlCopy.setValue(HtmlEntry.REFERENCED_LIBRARIES, task.referencedLibraries);
           _cache.storedAst(source);
           ChangeNoticeImpl notice = getNotice(source);
-          notice.setErrors(htmlEntry.allErrors, lineInfo);
+          notice.setErrors(htmlCopy.allErrors, lineInfo);
         } else {
           htmlCopy.recordParseError();
           _cache.removedAst(source);
         }
         htmlCopy.exception = thrownException;
         _cache.put(source, htmlCopy);
         htmlEntry = htmlCopy;
       } else {
         logInformation2("Parse results discarded for ${debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${htmlEntry.modificationTime}", thrownException);
         HtmlEntryImpl htmlCopy = (sourceEntry as HtmlEntry).writableCopy;
@@ skipping 42 matching lines @@
    *
    * @param task the task that was performed
    * @throws AnalysisException if the results could not be recorded
    */
   HtmlEntry recordResolveAngularComponentTemplateTaskResults(ResolveAngularComponentTemplateTask task) {
     Source source = task.source;
     AnalysisException thrownException = task.exception;
     HtmlEntry htmlEntry = null;
     {
       SourceEntry sourceEntry = _cache.get(source);
-      if (sourceEntry is! HtmlEntry) {
+      if (sourceEntry == null) {
+        throw new ObsoleteSourceAnalysisException(source);
+      } else if (sourceEntry is! HtmlEntry) {
         // This shouldn't be possible because we should never have performed the task if the source
         // didn't represent an HTML file, but check to be safe.
         throw new AnalysisException.con1("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
       }
       htmlEntry = sourceEntry as HtmlEntry;
-      int sourceTime = source.modificationStamp;
+      int sourceTime = getModificationStamp(source);
       int resultTime = task.modificationTime;
       if (sourceTime == resultTime) {
         if (htmlEntry.modificationTime != sourceTime) {
           // The source has changed without the context being notified. Simulate notification.
           sourceChanged(source);
           htmlEntry = getReadableHtmlEntry(source);
           if (htmlEntry == null) {
             throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
           }
         }
         HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
         if (thrownException == null) {
           htmlCopy.setValue(HtmlEntry.ANGULAR_ERRORS, task.resolutionErrors);
+          // notify about errors
           ChangeNoticeImpl notice = getNotice(source);
           notice.htmlUnit = task.resolvedUnit;
           notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
         } else {
           htmlCopy.recordResolutionError();
         }
         htmlCopy.exception = thrownException;
         _cache.put(source, htmlCopy);
         htmlEntry = htmlCopy;
       } else {
@@ skipping 40 matching lines @@
    *
    * @param task the task that was performed
    * @throws AnalysisException if the results could not be recorded
    */
   HtmlEntry recordResolveAngularEntryHtmlTaskResults(ResolveAngularEntryHtmlTask task) {
     Source source = task.source;
     AnalysisException thrownException = task.exception;
     HtmlEntry htmlEntry = null;
     {
       SourceEntry sourceEntry = _cache.get(source);
-      if (sourceEntry is! HtmlEntry) {
+      if (sourceEntry == null) {
+        throw new ObsoleteSourceAnalysisException(source);
+      } else if (sourceEntry is! HtmlEntry) {
         // This shouldn't be possible because we should never have performed the task if the source
         // didn't represent an HTML file, but check to be safe.
         throw new AnalysisException.con1("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
       }
       htmlEntry = sourceEntry as HtmlEntry;
-      int sourceTime = source.modificationStamp;
+      int sourceTime = getModificationStamp(source);
       int resultTime = task.modificationTime;
       if (sourceTime == resultTime) {
         if (htmlEntry.modificationTime != sourceTime) {
           // The source has changed without the context being notified. Simulate notification.
           sourceChanged(source);
           htmlEntry = getReadableHtmlEntry(source);
           if (htmlEntry == null) {
             throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
           }
         }
         HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
         if (thrownException == null) {
-          htmlCopy.setValue(HtmlEntry.ANGULAR_ERRORS, task.resolutionErrors);
+          htmlCopy.setValue(HtmlEntry.RESOLVED_UNIT, task.resolvedUnit);
+          recordAngularEntryPoint(htmlCopy, task);
+          _cache.storedAst(source);
           ChangeNoticeImpl notice = getNotice(source);
           notice.htmlUnit = task.resolvedUnit;
           notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
         } else {
           htmlCopy.recordResolutionError();
         }
         htmlCopy.exception = thrownException;
         _cache.put(source, htmlCopy);
         htmlEntry = htmlCopy;
       } else {
@@ skipping 41 matching lines @@
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   DartEntry recordResolveDartDependenciesTaskResults(ResolveDartDependenciesTask task) {
     Source source = task.source;
     AnalysisException thrownException = task.exception;
     DartEntry dartEntry = null;
     {
       SourceEntry sourceEntry = _cache.get(source);
-      if (sourceEntry is! DartEntry) {
+      if (sourceEntry == null) {
+        throw new ObsoleteSourceAnalysisException(source);
+      } else if (sourceEntry is! DartEntry) {
         // This shouldn't be possible because we should never have performed the task if the source
         // didn't represent a Dart file, but check to be safe.
         throw new AnalysisException.con1("Internal error: attempting to resolve Dart dependencies in a non-Dart file: ${source.fullName}");
       }
       dartEntry = sourceEntry as DartEntry;
-      int sourceTime = source.modificationStamp;
+      int sourceTime = getModificationStamp(source);
       int resultTime = task.modificationTime;
       if (sourceTime == resultTime) {
         if (dartEntry.modificationTime != sourceTime) {
           // The source has changed without the context being notified. Simulate notification.
           sourceChanged(source);
           dartEntry = getReadableDartEntry(source);
           if (dartEntry == null) {
             throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
           }
         }
@@ skipping 62 matching lines @@
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   SourceEntry recordResolveDartUnitTaskResults(ResolveDartUnitTask task) {
     Source unitSource = task.source;
     Source librarySource = task.librarySource;
     AnalysisException thrownException = task.exception;
     DartEntry dartEntry = null;
     {
       SourceEntry sourceEntry = _cache.get(unitSource);
-      if (sourceEntry is! DartEntry) {
+      if (sourceEntry == null) {
+        throw new ObsoleteSourceAnalysisException(unitSource);
+      } else if (sourceEntry is! DartEntry) {
         // This shouldn't be possible because we should never have performed the task if the source
         // didn't represent a Dart file, but check to be safe.
         throw new AnalysisException.con1("Internal error: attempting to resolve non-Dart file as a Dart file: ${unitSource.fullName}");
       }
       dartEntry = sourceEntry as DartEntry;
-      int sourceTime = unitSource.modificationStamp;
+      int sourceTime = getModificationStamp(unitSource);
       int resultTime = task.modificationTime;
       if (sourceTime == resultTime) {
         if (dartEntry.modificationTime != sourceTime) {
           // The source has changed without the context being notified. Simulate notification.
           sourceChanged(unitSource);
           dartEntry = getReadableDartEntry(unitSource);
           if (dartEntry == null) {
             throw new AnalysisException.con1("A Dart file became a non-Dart file: ${unitSource.fullName}");
           }
         }
@@ skipping 50 matching lines @@
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   SourceEntry recordResolveHtmlTaskResults(ResolveHtmlTask task) {
     Source source = task.source;
     AnalysisException thrownException = task.exception;
     HtmlEntry htmlEntry = null;
     {
       SourceEntry sourceEntry = _cache.get(source);
-      if (sourceEntry is! HtmlEntry) {
+      if (sourceEntry == null) {
+        throw new ObsoleteSourceAnalysisException(source);
+      } else if (sourceEntry is! HtmlEntry) {
         // This shouldn't be possible because we should never have performed the task if the source
         // didn't represent an HTML file, but check to be safe.
         throw new AnalysisException.con1("Internal error: attempting to resolve non-HTML file as an HTML file: ${source.fullName}");
       }
       htmlEntry = sourceEntry as HtmlEntry;
-      int sourceTime = source.modificationStamp;
+      int sourceTime = getModificationStamp(source);
       int resultTime = task.modificationTime;
       if (sourceTime == resultTime) {
         if (htmlEntry.modificationTime != sourceTime) {
           // The source has changed without the context being notified. Simulate notification.
           sourceChanged(source);
           htmlEntry = getReadableHtmlEntry(source);
           if (htmlEntry == null) {
             throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
           }
         }
         HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
         if (thrownException == null) {
           htmlCopy.setState(HtmlEntry.PARSED_UNIT, CacheState.FLUSHED);
           htmlCopy.setValue(HtmlEntry.RESOLVED_UNIT, task.resolvedUnit);
           htmlCopy.setValue(HtmlEntry.ELEMENT, task.element);
           htmlCopy.setValue(HtmlEntry.RESOLUTION_ERRORS, task.resolutionErrors);
           _cache.storedAst(source);
           ChangeNoticeImpl notice = getNotice(source);
           notice.htmlUnit = task.resolvedUnit;
           notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
         } else {
           htmlCopy.recordResolutionError();
           _cache.removedAst(source);
         }
         htmlCopy.exception = thrownException;
-        recordAngularComponents(htmlCopy, task.angularApplication);
         _cache.put(source, htmlCopy);
         htmlEntry = htmlCopy;
       } else {
         logInformation2("Resolution results discarded for ${debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${htmlEntry.modificationTime}", thrownException);
         HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
         if (thrownException == null || resultTime >= 0) {
           //
           // The analysis was performed on out-of-date sources. Mark the cache so that the sources
           // will be re-analyzed using the up-to-date sources.
           //
@@ skipping 19 matching lines @@
         htmlEntry = htmlCopy;
       }
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return htmlEntry;
   }
 
   /**
+   * Record the results produced by performing a [ScanDartTask]. If the results were computed
+   * from data that is now out-of-date, then the results will not be recorded.
+   *
+   * @param task the task that was performed
+   * @return an entry containing the computed results
+   * @throws AnalysisException if the results could not be recorded
+   */
+  DartEntry recordScanDartTaskResults(ScanDartTask task) {
+    Source source = task.source;
+    AnalysisException thrownException = task.exception;
+    DartEntry dartEntry = null;
+    {
+      SourceEntry sourceEntry = _cache.get(source);
+      if (sourceEntry == null) {
+        throw new ObsoleteSourceAnalysisException(source);
+      } else if (sourceEntry is! DartEntry) {
+        // This shouldn't be possible because we should never have performed the task if the source
+        // didn't represent a Dart file, but check to be safe.
+        throw new AnalysisException.con1("Internal error: attempting to parse non-Dart file as a Dart file: ${source.fullName}");
+      }
+      dartEntry = sourceEntry as DartEntry;
+      int sourceTime = getModificationStamp(source);
+      int resultTime = task.modificationTime;
+      if (sourceTime == resultTime) {
+        if (dartEntry.modificationTime != sourceTime) {
+          // The source has changed without the context being notified. Simulate notification.
+          sourceChanged(source);
+          dartEntry = getReadableDartEntry(source);
+          if (dartEntry == null) {
+            throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
+          }
+        }
+        DartEntryImpl dartCopy = dartEntry.writableCopy;
+        if (thrownException == null) {
+          LineInfo lineInfo = task.lineInfo;
+          dartCopy.setValue(SourceEntry.LINE_INFO, lineInfo);
+          dartCopy.setValue(DartEntry.TOKEN_STREAM, task.tokenStream);
+          dartCopy.setValue(DartEntry.SCAN_ERRORS, task.errors);
+          _cache.storedAst(source);
+          _workManager.add(source, SourcePriority.NORMAL_PART);
+          ChangeNoticeImpl notice = getNotice(source);
+          notice.setErrors(dartEntry.allErrors, lineInfo);
+        } else {
+          removeFromParts(source, dartEntry);
+          dartCopy.recordScanError();
+          _cache.removedAst(source);
+        }
+        dartCopy.exception = thrownException;
+        _cache.put(source, dartCopy);
+        dartEntry = dartCopy;
+      } else {
+        logInformation2("Scan results discarded for ${debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
+        DartEntryImpl dartCopy = dartEntry.writableCopy;
+        if (thrownException == null || resultTime >= 0) {
+          //
+          // The analysis was performed on out-of-date sources. Mark the cache so that the sources
+          // will be re-analyzed using the up-to-date sources.
+          //
+          //          dartCopy.recordScanNotInProcess();
+          removeFromParts(source, dartEntry);
+          dartCopy.invalidateAllInformation();
+          dartCopy.modificationTime = sourceTime;
+          _cache.removedAst(source);
+          _workManager.add(source, SourcePriority.UNKNOWN);
+        } else {
+          //
+          // We could not determine whether the sources were up-to-date or out-of-date. Mark the
+          // cache so that we won't attempt to re-analyze the sources until there's a good chance
+          // that we'll be able to do so without error.
+          //
+          dartCopy.recordScanError();
+        }
+        dartCopy.exception = thrownException;
+        _cache.put(source, dartCopy);
+        dartEntry = dartCopy;
+      }
+    }
+    if (thrownException != null) {
+      throw thrownException;
+    }
+    return dartEntry;
+  }
+
+  /**
    * Remove the given library from the list of containing libraries for all of the parts referenced
    * by the given entry.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param librarySource the library to be removed
    * @param dartEntry the entry containing the list of included parts
    */
   void removeFromParts(Source librarySource, DartEntry dartEntry) {
     List<Source> oldParts = dartEntry.getValue(DartEntry.INCLUDED_PARTS);
@@ skipping 36 matching lines @@
    * @return `true` if the new source is a Dart file
    */
   bool sourceAvailable(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
       sourceEntry = createSourceEntry(source);
       logInformation("Added new source: ${debuggingString(source)}");
     } else {
       SourceEntryImpl sourceCopy = sourceEntry.writableCopy;
       int oldTime = sourceCopy.modificationTime;
-      sourceCopy.modificationTime = source.modificationStamp;
+      sourceCopy.modificationTime = getModificationStamp(source);
       // TODO(brianwilkerson) Understand why we're not invalidating the cache.
       _cache.put(source, sourceCopy);
       logInformation("Added new source: ${debuggingString(source)} (previously modified at ${oldTime})");
     }
     if (sourceEntry is HtmlEntry) {
       _workManager.add(source, SourcePriority.HTML);
     } else {
       _workManager.add(source, SourcePriority.UNKNOWN);
     }
     return sourceEntry is DartEntry;
   }
 
   /**
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source that has been changed
    */
   void sourceChanged(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
-    if (sourceEntry == null || sourceEntry.modificationTime == source.modificationStamp) {
+    if (sourceEntry == null || sourceEntry.modificationTime == getModificationStamp(source)) {
       // Either we have removed this source, in which case we don't care that it is changed, or we
       // have already invalidated the cache and don't need to invalidate it again.
       if (sourceEntry == null) {
         logInformation("Modified source, but there is no entry: ${debuggingString(source)}");
       } else {
         logInformation("Modified source, but modification time matches: ${debuggingString(source)}");
       }
       return;
     }
     if (sourceEntry is HtmlEntry) {
       HtmlEntryImpl htmlCopy = sourceEntry.writableCopy;
       int oldTime = htmlCopy.modificationTime;
-      htmlCopy.modificationTime = source.modificationStamp;
+      htmlCopy.modificationTime = getModificationStamp(source);
+      invalidateAngularResolution(htmlCopy);
       htmlCopy.invalidateAllInformation();
       _cache.put(source, htmlCopy);
       _cache.removedAst(source);
       _workManager.add(source, SourcePriority.HTML);
       logInformation("Modified HTML source: ${debuggingString(source)} (previously modified at ${oldTime})");
     } else if (sourceEntry is DartEntry) {
       List<Source> containingLibraries = getLibrariesContaining(source);
       Set<Source> librariesToInvalidate = new Set<Source>();
       for (Source containingLibrary in containingLibraries) {
         librariesToInvalidate.add(containingLibrary);
         for (Source dependentLibrary in getLibrariesDependingOn(containingLibrary)) {
           librariesToInvalidate.add(dependentLibrary);
         }
       }
       PrintStringWriter writer = new PrintStringWriter();
       int oldTime = sourceEntry.modificationTime;
       writer.println("Modified Dart source: ${debuggingString(source)} (previously modified at ${oldTime})");
       for (Source library in librariesToInvalidate) {
         //    for (Source library : containingLibraries) {
         invalidateLibraryResolution(library, writer);
       }
-      removeFromParts(source, sourceEntry);
-      DartEntryImpl dartCopy = sourceEntry.writableCopy;
-      dartCopy.modificationTime = source.modificationStamp;
+      removeFromParts(source, _cache.get(source) as DartEntry);
+      DartEntryImpl dartCopy = (_cache.get(source) as DartEntry).writableCopy;
+      dartCopy.modificationTime = getModificationStamp(source);
       dartCopy.invalidateAllInformation();
       _cache.put(source, dartCopy);
       _cache.removedAst(source);
       _workManager.add(source, SourcePriority.UNKNOWN);
       logInformation(writer.toString());
     }
   }
 
   /**
    * <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) {
     PrintStringWriter writer = new PrintStringWriter();
     writer.println("Removed source: ${debuggingString(source)}");
     SourceEntry sourceEntry = _cache.get(source);
-    if (sourceEntry is DartEntry) {
+    if (sourceEntry is HtmlEntry) {
+      HtmlEntryImpl htmlCopy = sourceEntry.writableCopy;
+      invalidateAngularResolution(htmlCopy);
+    } else if (sourceEntry is DartEntry) {
       Set<Source> libraries = new Set<Source>();
       for (Source librarySource in getLibrariesContaining(source)) {
         libraries.add(librarySource);
         for (Source dependentLibrary in getLibrariesDependingOn(librarySource)) {
           libraries.add(dependentLibrary);
         }
       }
       for (Source librarySource in libraries) {
         invalidateLibraryResolution(librarySource, writer);
       }
@@ skipping 14 matching lines @@
    * @return `true` if at least one entry was invalid
    */
   bool validateCacheConsistency() {
     int consistencyCheckStart = JavaSystem.nanoTime();
     List<Source> missingSources = new List<Source>();
     int inconsistentCount = 0;
     {
       for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
         Source source = entry.getKey();
         SourceEntry sourceEntry = entry.getValue();
-        int sourceTime = source.modificationStamp;
+        int sourceTime = getModificationStamp(source);
         if (sourceTime != sourceEntry.modificationTime) {
           sourceChanged(source);
           inconsistentCount++;
         }
         if (sourceEntry.exception != null) {
-          if (!source.exists()) {
+          if (!exists(source)) {
             missingSources.add(source);
           }
         }
       }
     }
     int consistencyCheckEnd = JavaSystem.nanoTime();
     PrintStringWriter writer = new PrintStringWriter();
     writer.print("Consistency check took ");
     writer.print((consistencyCheckEnd - consistencyCheckStart) / 1000000.0);
     writer.println(" ms and found");
@@ skipping 35 matching lines @@
 
   SourceEntry visitResolveAngularEntryHtmlTask(ResolveAngularEntryHtmlTask task) => AnalysisContextImpl_this.recordResolveAngularEntryHtmlTaskResults(task);
 
   DartEntry visitResolveDartDependenciesTask(ResolveDartDependenciesTask task) => AnalysisContextImpl_this.recordResolveDartDependenciesTaskResults(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);
+
+  SourceEntry visitScanDartTask(ScanDartTask task) => AnalysisContextImpl_this.recordScanDartTaskResults(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) {
@@ skipping 55 matching lines @@
    * A flag indicating whether analysis is to parse and analyze function bodies.
    */
   bool analyzeFunctionBodies = true;
 
   /**
    * A flag indicating whether analysis is to generate dart2js related hint results.
    */
   bool dart2jsHint = true;
 
   /**
+   * A flag indicating whether errors, warnings and hints should be generated for sources in the
+   * SDK.
+   */
+  bool _generateSdkErrors = false;
+
+  /**
    * A flag indicating whether analysis is to generate hint results (e.g. type inference based
    * information and pub best practices).
    */
   bool hint = true;
 
   /**
    * A flag indicating whether incremental analysis should be used.
    */
   bool incremental = false;
 
   /**
    * A flag indicating whether analysis is to parse comments.
    */
   bool preserveComments = true;
 
   /**
-   * A flag indicating whether analysis is to parse comments.
+   * A flag indicating whether analysis is to analyze Angular.
    */
   bool analyzeAngular = true;
 
   /**
    * Initialize a newly created set of analysis options to have their default values.
    */
   AnalysisOptionsImpl();
 
   /**
    * Initialize a newly created set of analysis options to have the same values as those in the
    * 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;
     incremental = options.incremental;
-    analyzeAngular = options.analyzeAngular;
+  }
+
+  bool get generateSdkErrors => _generateSdkErrors;
+
+  /**
+   * Set whether errors, warnings and hints should be generated for sources in the SDK to match the
+   * given value.
+   *
+   * @param generate `true` if errors, warnings and hints should be generated for sources in
+   *          the SDK
+   */
+  void set generateSdkErrors(bool generate) {
+    _generateSdkErrors = generate;
   }
 }
 
 /**
  * Instances of the class `ChangeNoticeImpl` represent a change to the analysis results
  * associated with a given source.
  *
  * @coverage dart.engine
  */
 class ChangeNoticeImpl implements ChangeNotice {
@@ skipping 45 matching lines @@
    * Set the errors that changed as a result of the analysis to the given errors and set the line
    * information to the given line information.
    *
    * @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());
+      AnalysisEngine.instance.logger.logInformation3("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.
@@ skipping 529 matching lines @@
     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();
-    }
-  }
+  List<Source> computeExportedLibraries(Source source) => _basis.computeExportedLibraries(source);
 
   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();
-    }
-  }
+  List<Source> computeImportedLibraries(Source source) => _basis.computeImportedLibraries(source);
 
   SourceKind computeKindOf(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-computeKindOf");
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.computeKindOf(source);
     } finally {
       instrumentation.log();
     }
   }
@@ skipping 23 matching lines @@
       instrumentation.log();
     }
   }
 
   ResolvableHtmlUnit computeResolvableAngularComponentHtmlUnit(Source source) => _basis.computeResolvableAngularComponentHtmlUnit(source);
 
   ResolvableCompilationUnit computeResolvableCompilationUnit(Source source) => _basis.computeResolvableCompilationUnit(source);
 
   ResolvableHtmlUnit computeResolvableHtmlUnit(Source source) => _basis.computeResolvableHtmlUnit(source);
 
+  bool exists(Source source) {
+    InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-exists");
+    try {
+      instrumentation.metric3("contextId", _contextId);
+      return _basis.exists(source);
+    } finally {
+      instrumentation.log();
+    }
+  }
+
   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();
     }
   }
 
   /**
    * @return the underlying [AnalysisContext].
    */
   AnalysisContext get basis => _basis;
 
+  CompilationUnitElement getCompilationUnitElement(Source unitSource, Source librarySource) {
+    InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getCompilationUnitElement");
+    try {
+      instrumentation.metric3("contextId", _contextId);
+      return _basis.getCompilationUnitElement(unitSource, librarySource);
+    } finally {
+      instrumentation.log();
+    }
+  }
+
+  TimestampedData<String> getContents(Source source) => _basis.getContents(source);
+
+  void getContents2(Source source, Source_ContentReceiver receiver) {
+    _basis.getContents2(source, receiver);
+  }
+
   Element getElement(ElementLocation location) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getElement");
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.getElement(location);
     } finally {
       instrumentation.log();
     }
   }
 
@@ skipping 140 matching lines @@
   }
 
   LineInfo getLineInfo(Source source) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getLineInfo");
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.getLineInfo(source);
     } finally {
       instrumentation.log();
     }
+  }
+
+  int getModificationStamp(Source source) {
+    InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getModificationStamp");
+    try {
+      instrumentation.metric3("contextId", _contextId);
+      return _basis.getModificationStamp(source);
+    } finally {
+      instrumentation.log();
+    }
   }
 
   Namespace getPublicNamespace(LibraryElement library) => _basis.getPublicNamespace(library);
 
   Namespace getPublicNamespace2(Source source) => _basis.getPublicNamespace2(source);
 
-  List<Source> get refactoringUnsafeSources => _basis.refactoringUnsafeSources;
+  List<Source> get refactoringUnsafeSources {
+    InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getRefactoringUnsafeSources");
+    try {
+      instrumentation.metric3("contextId", _contextId);
+      return _basis.refactoringUnsafeSources;
+    } finally {
+      instrumentation.log();
+    }
+  }
 
   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();
     }
   }
@@ skipping 25 matching lines @@
       return _basis.sourceFactory;
     } finally {
       instrumentation.log2(2);
     }
   }
 
   AnalysisContentStatistics get statistics => _basis.statistics;
 
   TypeProvider get typeProvider => _basis.typeProvider;
 
+  TimestampedData<CompilationUnit> internalParseCompilationUnit(Source source) => _basis.internalParseCompilationUnit(source);
+
   TimestampedData<CompilationUnit> internalResolveCompilationUnit(Source unitSource, LibraryElement libraryElement) => _basis.internalResolveCompilationUnit(unitSource, libraryElement);
 
+  TimestampedData<Token> internalScanTokenStream(Source source) => _basis.internalScanTokenStream(source);
+
   bool isClientLibrary(Source librarySource) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-isClientLibrary");
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.isClientLibrary(librarySource);
     } finally {
       instrumentation.log();
     }
   }
 
@@ skipping 145 matching lines @@
 
   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.
    *
@@ skipping 93 matching lines @@
   /**
    * Returns a type provider for this context or throws an exception if dart:core cannot be
    * resolved.
    *
    * @return the type provider (not `null`)
    * @throws AnalysisException if dart:core cannot be resolved
    */
   TypeProvider get typeProvider;
 
   /**
+   * Return a time-stamped parsed AST for the given source.
+   *
+   * @param source the source of the compilation unit for which an AST is to be returned
+   * @return a time-stamped AST for the source
+   * @throws AnalysisException if the source could not be parsed
+   */
+  TimestampedData<CompilationUnit> internalParseCompilationUnit(Source source);
+
+  /**
    * Return a time-stamped fully-resolved compilation unit for the given source in the given
    * library.
    *
    * @param unitSource the source of the compilation unit for which a resolved AST structure is to
    *          be returned
    * @param libraryElement the element representing the library in which the compilation unit is to
    *          be resolved
    * @return a time-stamped fully-resolved compilation unit for the source
    * @throws AnalysisException if the resolved compilation unit could not be computed
    */
   TimestampedData<CompilationUnit> internalResolveCompilationUnit(Source unitSource, LibraryElement libraryElement);
 
   /**
+   * Return a time-stamped token stream for the given source.
+   *
+   * @param source the source of the compilation unit for which a token stream is to be returned
+   * @return a time-stamped token stream for the source
+   * @throws AnalysisException if the token stream could not be computed
+   */
+  TimestampedData<Token> internalScanTokenStream(Source source);
+
+  /**
    * 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);
 }
 
 /**
@@ skipping 502 matching lines @@
       List<ToolkitObjectElement> toolkitObjects = local.toolkitObjects;
       if (toolkitObjects.length == 1 && toolkitObjects[0] is AngularElement) {
         return toolkitObjects[0] as AngularElement;
       }
     }
     // not a special Element
     return null;
   }
 
   /**
-   * Returns the array of all top-level Angular elements that could be used in the application with
-   * this entry point. Maybe `null` of not an Angular entry point.
-   */
-  static List<AngularElement> getAngularElements(AnalysisContext context, ht.HtmlUnit unit) {
-    if (hasAngularAnnotation(unit)) {
-      CompilationUnit dartUnit = getDartUnit(context, unit);
-      if (dartUnit != null) {
-        LibraryElement libraryElement = dartUnit.element.library;
-        return getAngularElements2(libraryElement);
-      }
-    }
-    return null;
-  }
-
-  /**
    * @return `true` if the given [HtmlUnit] has <code>ng-app</code> annotation.
    */
   static bool hasAngularAnnotation(ht.HtmlUnit htmlUnit) {
     try {
       htmlUnit.accept(new RecursiveXmlVisitor_AngularHtmlUnitResolver_hasAngularAnnotation());
     } on AngularHtmlUnitResolver_FoundAppError catch (e) {
       return true;
     }
     return false;
   }
@@ skipping 17 matching lines @@
     }
   }
 
   /**
    * Returns the array of all top-level Angular elements that could be used in this library.
    *
    * @param libraryElement the [LibraryElement] to analyze
    * @return the array of all top-level Angular elements that could be used in this library
    */
   static void addAngularElements2(Set<AngularElement> angularElements, LibraryElement library, Set<LibraryElement> visited) {
+    if (library == null) {
+      return;
+    }
     if (!visited.add(library)) {
       return;
     }
     // add Angular elements from current library
     for (CompilationUnitElement unit in library.units) {
+      angularElements.addAll(unit.angularViews);
       for (ClassElement type in unit.types) {
         addAngularElements(angularElements, type);
       }
     }
     // handle imports
     for (ImportElement importElement in library.imports) {
       LibraryElement importedLibrary = importElement.importedLibrary;
       addAngularElements2(angularElements, importedLibrary, visited);
     }
   }
 
   static StringToken createStringToken(String name, int offset) => new StringToken(TokenType.IDENTIFIER, name, offset);
 
   /**
    * Returns the array of all top-level Angular elements that could be used in this library.
    *
    * @param libraryElement the [LibraryElement] to analyze
    * @return the array of all top-level Angular elements that could be used in this library
    */
-  static List<AngularElement> getAngularElements2(LibraryElement libraryElement) {
+  static List<AngularElement> getAngularElements(Set<LibraryElement> libraries, LibraryElement libraryElement) {
     Set<AngularElement> angularElements = new Set();
-    addAngularElements2(angularElements, libraryElement, new Set());
+    addAngularElements2(angularElements, libraryElement, libraries);
     return new List.from(angularElements);
   }
 
   /**
    * Returns the external Dart [CompilationUnit] referenced by the given [HtmlUnit].
    */
   static CompilationUnit getDartUnit(AnalysisContext context, ht.HtmlUnit unit) {
     for (HtmlScriptElement script in unit.element.scripts) {
       if (script is ExternalHtmlScriptElement) {
         Source scriptSource = script.scriptSource;
         if (scriptSource != null) {
           return context.resolveCompilationUnit2(scriptSource, scriptSource);
         }
       }
     }
     return null;
   }
 
+  static Set<Source> getLibrarySources(Set<LibraryElement> libraries) {
+    Set<Source> sources = new Set();
+    for (LibraryElement library in libraries) {
+      sources.add(library.source);
+    }
+    return sources;
+  }
+
   InternalAnalysisContext _context;
 
   TypeProvider _typeProvider;
 
-  AnalysisErrorListener _errorListener;
+  AngularHtmlUnitResolver_FilteringAnalysisErrorListener _errorListener;
 
   Source _source;
 
   LineInfo _lineInfo;
 
   ht.HtmlUnit _unit;
 
   List<AngularElement> _angularElements;
 
   List<NgProcessor> _processors = [];
@@ skipping 12 matching lines @@
 
   Set<LibraryElement> _injectedLibraries = new Set();
 
   Scope _topNameScope;
 
   Scope _nameScope;
 
   AngularHtmlUnitResolver(InternalAnalysisContext context, AnalysisErrorListener errorListener, Source source, LineInfo lineInfo, ht.HtmlUnit unit) {
     this._context = context;
     this._typeProvider = context.typeProvider;
-    this._errorListener = errorListener;
+    this._errorListener = new AngularHtmlUnitResolver_FilteringAnalysisErrorListener(errorListener);
     this._source = source;
     this._lineInfo = lineInfo;
     this._unit = unit;
   }
 
   /**
-   * The [AngularApplicationInfo] for the Web application with this entry point, may be
+   * The [AngularApplication] for the Web application with this entry point, may be
    * `null` if not an entry point.
    */
-  AngularApplicationInfo calculateAngularApplication() {
+  AngularApplication calculateAngularApplication() {
     // check if Angular at all
     if (!hasAngularAnnotation(_unit)) {
       return null;
     }
     // prepare resolved Dart unit
     CompilationUnit dartUnit = getDartUnit(_context, _unit);
     if (dartUnit == null) {
       return null;
     }
     // prepare accessible Angular elements
     LibraryElement libraryElement = dartUnit.element.library;
-    List<AngularElement> angularElements = getAngularElements2(libraryElement);
-    // resolve template URIs
+    Set<LibraryElement> libraries = new Set();
+    List<AngularElement> angularElements = getAngularElements(libraries, libraryElement);
+    // resolve AngularComponentElement template URIs
     // TODO(scheglov) resolve to HtmlElement to allow F3 ?
+    Set<Source> angularElementsSources = new Set();
     for (AngularElement angularElement in angularElements) {
-      if (angularElement is AngularComponentElement) {
-        AngularComponentElement component = angularElement;
-        String templateUri = component.templateUri;
+      if (angularElement is AngularHasTemplateElement) {
+        AngularHasTemplateElement hasTemplate = angularElement;
+        angularElementsSources.add(angularElement.source);
+        String templateUri = hasTemplate.templateUri;
         if (templateUri == null) {
           continue;
         }
         try {
           Source templateSource = _source.resolveRelative(parseUriWithException(templateUri));
-          if (templateSource == null || !templateSource.exists()) {
+          if (!_context.exists(templateSource)) {
             templateSource = _context.sourceFactory.resolveUri(_source, "package:${templateUri}");
-            if (templateSource == null || !templateSource.exists()) {
-              reportError7(component.templateUriOffset, templateUri.length, AngularCode.URI_DOES_NOT_EXIST, [templateUri]);
+            if (!_context.exists(templateSource)) {
+              _errorListener.onError(new AnalysisError.con2(angularElement.source, hasTemplate.templateUriOffset, templateUri.length, AngularCode.URI_DOES_NOT_EXIST, [templateUri]));
               continue;
             }
           }
           if (!AnalysisEngine.isHtmlFileName(templateUri)) {
             continue;
           }
-          (component as AngularComponentElementImpl).templateSource = templateSource;
+          if (hasTemplate is AngularComponentElementImpl) {
+            hasTemplate.templateSource = templateSource;
+          }
+          if (hasTemplate is AngularViewElementImpl) {
+            hasTemplate.templateSource = templateSource;
+          }
         } on URISyntaxException catch (exception) {
-          reportError7(component.templateUriOffset, templateUri.length, AngularCode.INVALID_URI, [templateUri]);
+          _errorListener.onError(new AnalysisError.con2(angularElement.source, hasTemplate.templateUriOffset, templateUri.length, AngularCode.INVALID_URI, [templateUri]));
         }
       }
     }
+    // create AngularApplication
+    AngularApplication application = new AngularApplication(_source, getLibrarySources(libraries), angularElements, new List.from(angularElementsSources));
+    // set AngularApplication for each AngularElement
+    for (AngularElement angularElement in angularElements) {
+      (angularElement as AngularElementImpl).application = application;
+    }
     // done
-    return new AngularApplicationInfo(_source, angularElements);
+    return application;
   }
 
   /**
    * Resolves [source] as an [AngularComponentElement] template file.
    *
    * @param application the Angular application we are resolving for
    * @param component the [AngularComponentElement] to resolve template for, not `null`
    */
-  void resolveComponentTemplate(AngularApplicationInfo application, AngularComponentElement component) {
+  void resolveComponentTemplate(AngularApplication application, AngularComponentElement component) {
     _isAngular = true;
     resolveInternal(application.elements, component);
   }
 
   /**
    * Resolves [source] as an Angular application entry point.
    */
-  void resolveEntryPoint(AngularApplicationInfo application) {
+  void resolveEntryPoint(AngularApplication application) {
     resolveInternal(application.elements, null);
   }
 
   Object visitXmlAttributeNode(ht.XmlAttributeNode node) {
     parseEmbeddedExpressions2(node);
     resolveExpressions(node.expressions);
     return super.visitXmlAttributeNode(node);
   }
 
   Object visitXmlTagNode(ht.XmlTagNode node) {
@@ skipping 245 matching lines @@
     // add Scope variables - no type, no location, just to avoid warnings
     {
       Type2 type = _typeProvider.dynamicType;
       _topNameScope.define(createLocalVariable2(type, "\$id"));
       _topNameScope.define(createLocalVariable2(type, "\$parent"));
       _topNameScope.define(createLocalVariable2(type, "\$root"));
     }
   }
 
   /**
-   * Defines variable for the given [AngularElement].
+   * Defines variable for the given [AngularElement] with type of the enclosing
+   * [ClassElement].
    */
-  void defineTopElementVariable(AngularElement element) {
+  void defineTopVariable_forClassElement(AngularElement element) {
     ClassElement classElement = element.enclosingElement as ClassElement;
     InterfaceType type = classElement.type;
     LocalVariableElementImpl variable = createLocalVariable2(type, element.name);
     defineTopVariable(variable);
     variable.toolkitObjects = <AngularElement> [element];
   }
 
   /**
+   * Defines variable for the given [AngularScopePropertyElement].
+   */
+  void defineTopVariable_forScopeProperty(AngularScopePropertyElement element) {
+    Type2 type = element.type;
+    LocalVariableElementImpl variable = createLocalVariable2(type, element.name);
+    defineTopVariable(variable);
+    variable.toolkitObjects = <AngularElement> [element];
+  }
+
+  /**
    * Parse the value of the given token for embedded expressions, and add any embedded expressions
    * that are found to the given list of expressions.
    *
    * @param expressions the list to which embedded expressions are to be added
    * @param token the token whose value is to be parsed
    */
   void parseEmbeddedExpressions(List<AngularMoustacheXmlExpression> expressions, ht.Token token) {
     // prepare Token information
     String lexeme = token.lexeme;
     int offset = token.offset;
@@ skipping 82 matching lines @@
    */
   void resolveInternal(List<AngularElement> angularElements, AngularComponentElement component) {
     this._angularElements = angularElements;
     // add built-in processors
     _processors.add(NgModelProcessor.INSTANCE);
     // _processors.add(NgRepeatProcessor.INSTANCE);
     // add element's libraries
     for (AngularElement angularElement in angularElements) {
       _injectedLibraries.add(angularElement.library);
     }
-    // add accessible processors
-    for (AngularElement angularElement in angularElements) {
-      NgProcessor processor = createProcessor(angularElement);
-      if (processor != null) {
-        _processors.add(processor);
-      }
-    }
     // prepare Dart library
     createLibraryElement();
     (_unit.element as HtmlElementImpl).angularCompilationUnit = _unitElement;
     // prepare Dart resolver
     createResolver();
     // maybe resolving component template
     if (component != null) {
-      defineTopElementVariable(component);
+      defineTopVariable_forClassElement(component);
+      for (AngularScopePropertyElement scopeProperty in component.scopeProperties) {
+        defineTopVariable_forScopeProperty(scopeProperty);
+      }
+    }
+    // add processors
+    for (AngularElement angularElement in angularElements) {
+      NgProcessor processor = createProcessor(angularElement);
+      if (processor != null) {
+        _processors.add(processor);
+      }
     }
     // define filters
     for (AngularElement angularElement in angularElements) {
       if (angularElement is AngularFilterElement) {
-        defineTopElementVariable(angularElement);
+        defineTopVariable_forClassElement(angularElement);
       }
     }
     // run this HTML visitor
     _unit.accept(this);
     // simulate imports for injects
     {
       List<ImportElement> imports = [];
       for (LibraryElement injectedLibrary in _injectedLibraries) {
         ImportElementImpl importElement = new ImportElementImpl(-1);
         importElement.importedLibrary = injectedLibrary;
@@ skipping 24 matching lines @@
   /**
    * The "ng-model" directive is special, it contributes to the top-level name scope. These models
    * can be used before actual "ng-model" attribute in HTML. So, we need to define them once we
    * found [NG_APP] context.
    */
   void visitModelDirectives(ht.XmlTagNode appNode) {
     appNode.accept(new RecursiveXmlVisitor_AngularHtmlUnitResolver_visitModelDirectives(this));
   }
 }
 
+class AngularHtmlUnitResolver_FilteringAnalysisErrorListener implements AnalysisErrorListener {
+  AnalysisErrorListener _listener;
+
+  AngularHtmlUnitResolver_FilteringAnalysisErrorListener(AnalysisErrorListener listener) {
+    this._listener = listener;
+  }
+
+  void onError(AnalysisError error) {
+    ErrorCode errorCode = error.errorCode;
+    if (identical(errorCode, StaticWarningCode.UNDEFINED_GETTER) || identical(errorCode, StaticWarningCode.UNDEFINED_IDENTIFIER) || identical(errorCode, StaticTypeWarningCode.UNDEFINED_GETTER)) {
+      return;
+    }
+    _listener.onError(error);
+  }
+}
+
 class AngularHtmlUnitResolver_FoundAppError extends Error {
 }
 
 class RecursiveXmlVisitor_AngularHtmlUnitResolver_hasAngularAnnotation extends ht.RecursiveXmlVisitor<Object> {
   Object visitXmlTagNode(ht.XmlTagNode node) {
     if (node.getAttribute(AngularHtmlUnitResolver._NG_APP) != null) {
       throw new AngularHtmlUnitResolver_FoundAppError();
     }
     return super.visitXmlTagNode(node);
   }
@@ skipping 213 matching lines @@
  * attributes as expressions.
  */
 class NgDirectiveElementProcessor extends NgDirectiveProcessor {
   AngularDirectiveElement _element;
 
   NgDirectiveElementProcessor(AngularDirectiveElement element) {
     this._element = element;
   }
 
   void apply(AngularHtmlUnitResolver resolver, ht.XmlTagNode node) {
+    String selectorAttributeName = null;
+    {
+      AngularSelectorElement selector = _element.selector;
+      if (selector is HasAttributeSelectorElementImpl) {
+        selectorAttributeName = selector.name;
+        // resolve attribute expression
+        ht.XmlAttributeNode attribute = node.getAttribute(selectorAttributeName);
+        if (attribute != null) {
+          attribute.element = selector;
+        }
+      }
+    }
+    //
     for (AngularPropertyElement property in _element.properties) {
       // prepare attribute name
       String name = property.name;
       if (name == ".") {
-        AngularSelectorElement selector = _element.selector;
-        if (selector is HasAttributeSelectorElementImpl) {
-          name = selector.name;
-        }
+        name = selectorAttributeName;
       }
       // resolve attribute expression
       ht.XmlAttributeNode attribute = node.getAttribute(name);
       if (attribute != null) {
-        attribute.element = property;
+        // if not resolved as the selector, resolve as a property
+        if (name != selectorAttributeName) {
+          attribute.element = property;
+        }
         // resolve if binding
         if (property.propertyKind != AngularPropertyKind.ATTR) {
           resolver.pushNameScope();
           try {
             onNgEventDirective(resolver);
             AngularExpression expression = parseAngularExpression(resolver, attribute);
             resolver.resolveExpression(expression);
             setExpression(attribute, expression);
           } finally {
             resolver.popNameScope();
@@ skipping 317 matching lines @@
   E visitResolveDartUnitTask(ResolveDartUnitTask task);
 
   /**
    * Visit a [ResolveHtmlTask].
    *
    * @param task the task to be visited
    * @return the result of visiting the task
    * @throws AnalysisException if the visitor throws an exception for some reason
    */
   E visitResolveHtmlTask(ResolveHtmlTask task);
+
+  /**
+   * Visit a [ScanDartTask].
+   *
+   * @param task the task to be visited
+   * @return the result of visiting the task
+   * @throws AnalysisException if the visitor throws an exception for some reason
+   */
+  E visitScanDartTask(ScanDartTask 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.
    */
@@ skipping 264 matching lines @@
    * The source to be parsed.
    */
   final Source source;
 
   /**
    * The time at which the contents of the source were last modified.
    */
   int _modificationTime = -1;
 
   /**
-   * The line information that was produced.
-   */
-  LineInfo _lineInfo;
-
-  /**
    * The compilation unit that was produced by parsing the source.
    */
   CompilationUnit _unit;
 
   /**
    * The errors that were produced by scanning and parsing the source.
    */
   List<AnalysisError> _errors = AnalysisError.NO_ERRORS;
 
   /**
@@ skipping 26 matching lines @@
 
   /**
    * Return the errors that were produced by scanning and parsing the source, or `null` if the
    * task has not yet been performed or if an exception occurred.
    *
    * @return the errors that were produced by scanning and parsing the source
    */
   List<AnalysisError> get errors => _errors;
 
   /**
-   * Return the line information that was produced, or `null` if the task has not yet been
-   * performed or if an exception occurred.
-   *
-   * @return the line information that was produced
-   */
-  LineInfo get lineInfo => _lineInfo;
-
-  /**
    * Return the time at which the contents of the source that was parsed were last modified, or a
    * negative value if the task has not yet been performed or if an exception occurred.
    *
    * @return the time at which the contents of the source that was parsed were last modified
    */
   int get modificationTime => _modificationTime;
 
   /**
    * Return `true` if the source contains a 'library' directive, or `false` if the task
    * has not yet been performed or if an exception occurred.
@@ skipping 12 matching lines @@
 
   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];
-    //
-    // Scan the contents of the file.
-    //
-    Source_ContentReceiver receiver = new Source_ContentReceiver_ParseDartTask_internalPerform(this, errorListener, token);
-    try {
-      source.getContents(receiver);
-    } on JavaException catch (exception) {
-      _modificationTime = source.modificationStamp;
-      throw new AnalysisException.con3(exception);
-    }
-    if (token[0] == null) {
-      throw new AnalysisException.con1("Could not get contents for '${source.fullName}'");
+    InternalAnalysisContext context = this.context;
+    TimestampedData<Token> data = context.internalScanTokenStream(source);
+    _modificationTime = data.modificationTime;
+    Token token = data.data;
+    if (token == null) {
+      throw new AnalysisException.con1("Could not get token stream for ${source.fullName}");
     }
     //
     // Then parse the token stream.
     //
     TimeCounter_TimeCounterHandle timeCounterParse = PerformanceStatistics.parse.start();
     try {
       Parser parser = new Parser(source, errorListener);
       parser.parseFunctionBodies = context.analysisOptions.analyzeFunctionBodies;
-      _unit = parser.parseCompilationUnit(token[0]);
+      _unit = parser.parseCompilationUnit(token);
       _errors = errorListener.getErrors2(source);
       for (Directive directive in _unit.directives) {
         if (directive is LibraryDirective) {
           _hasLibraryDirective2 = true;
         } else if (directive is PartOfDirective) {
           _hasPartOfDirective2 = true;
         }
       }
-      _unit.lineInfo = _lineInfo;
+      _unit.lineInfo = context.getLineInfo(source);
     } finally {
       timeCounterParse.stop();
     }
   }
 }
 
-class Source_ContentReceiver_ParseDartTask_internalPerform implements Source_ContentReceiver {
-  final ParseDartTask ParseDartTask_this;
-
-  RecordingErrorListener errorListener;
-
-  List<Token> token;
-
-  Source_ContentReceiver_ParseDartTask_internalPerform(this.ParseDartTask_this, this.errorListener, this.token);
-
-  void accept(String contents, int modificationTime) {
-    ParseDartTask_this._modificationTime = modificationTime;
-    TimeCounter_TimeCounterHandle timeCounterScan = PerformanceStatistics.scan.start();
-    try {
-      Scanner scanner = new Scanner(ParseDartTask_this.source, new CharSequenceReader(contents), errorListener);
-      scanner.preserveComments = ParseDartTask_this.context.analysisOptions.preserveComments;
-      token[0] = scanner.tokenize();
-      ParseDartTask_this._lineInfo = new LineInfo(scanner.lineStarts);
-    } finally {
-      timeCounterScan.stop();
-    }
-  }
-}
-
 /**
  * Instances of the class `ParseHtmlTask` parse a specific source as an HTML file.
  */
 class ParseHtmlTask extends AnalysisTask {
   /**
    * The source to be parsed.
    */
   final Source source;
 
   /**
@@ skipping 20 matching lines @@
    * An array containing the sources of the libraries that are referenced within the HTML.
    */
   List<Source> _referencedLibraries = Source.EMPTY_ARRAY;
 
   /**
    * The name of the 'src' attribute in a HTML tag.
    */
   static String _ATTRIBUTE_SRC = "src";
 
   /**
-   * The name of the 'type' attribute in a HTML tag.
-   */
-  static String _ATTRIBUTE_TYPE = "type";
-
-  /**
    * The name of the 'script' tag in an HTML file.
    */
   static String _TAG_SCRIPT = "script";
 
   /**
-   * The value of the 'type' attribute of a 'script' tag that indicates that the script is written
-   * in Dart.
-   */
-  static String _TYPE_DART = "application/dart";
-
-  /**
    * 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, this.source) : super(context);
 
   accept(AnalysisTaskVisitor visitor) => visitor.visitParseHtmlTask(this);
 
   /**
@@ skipping 35 matching lines @@
   List<Source> get referencedLibraries => _referencedLibraries;
 
   String get taskDescription {
     if (source == null) {
       return "parse as html null source";
     }
     return "parse as html ${source.fullName}";
   }
 
   void internalPerform() {
-    ht.HtmlScanner scanner = new ht.HtmlScanner(source);
     try {
-      source.getContents(scanner);
+      TimestampedData<String> contents = context.getContents(source);
+      _modificationTime = contents.modificationTime;
+      ht.AbstractScanner scanner = new ht.StringScanner(source, contents.data);
+      scanner.passThroughElements = <String> [_TAG_SCRIPT];
+      ht.Token token = scanner.tokenize();
+      _lineInfo = new LineInfo(scanner.lineStarts);
+      RecordingErrorListener errorListener = new RecordingErrorListener();
+      _unit = new ht.HtmlParser(source, errorListener).parse(token, _lineInfo);
+      _errors = errorListener.getErrors2(source);
+      _referencedLibraries = librarySources;
     } on JavaException catch (exception) {
       throw new AnalysisException.con3(exception);
     }
-    ht.HtmlScanResult scannerResult = scanner.result;
-    _modificationTime = scannerResult.modificationTime;
-    _lineInfo = new LineInfo(scannerResult.lineStarts);
-    RecordingErrorListener errorListener = new RecordingErrorListener();
-    ht.HtmlParseResult result = new ht.HtmlParser(source, errorListener).parse(scannerResult);
-    _unit = result.htmlUnit;
-    _errors = errorListener.getErrors2(source);
-    _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>();
     _unit.accept(new RecursiveXmlVisitor_ParseHtmlTask_getLibrarySources(this, libraries));
@@ skipping 16 matching lines @@
     for (ht.XmlAttributeNode attribute in node.attributes) {
       if (javaStringEqualsIgnoreCase(attribute.name, ParseHtmlTask._ATTRIBUTE_SRC)) {
         scriptAttribute = attribute;
       }
     }
     if (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()) {
+        if (ParseHtmlTask_this.context.exists(librarySource)) {
           libraries.add(librarySource);
         }
       } on URISyntaxException catch (e) {
       }
     }
     return super.visitHtmlScriptTagNode(node);
   }
 }
 
 /**
  * Instances of the class `ResolveAngularComponentTemplateTask` resolve HTML template
  * referenced by [AngularComponentElement].
  */
 class ResolveAngularComponentTemplateTask extends AnalysisTask {
   /**
    * The [AngularComponentElement] to resolve template for.
    */
   AngularComponentElement _component;
 
   /**
    * The Angular application to resolve in context of.
    */
-  AngularApplicationInfo _application;
+  AngularApplication _application;
 
   /**
    * The source to be resolved.
    */
   final Source source;
 
   /**
    * The time at which the contents of the source were last modified.
    */
   int _modificationTime = -1;
 
   /**
    * The [HtmlUnit] that was resolved by this task.
    */
   ht.HtmlUnit _resolvedUnit;
 
   /**
    * 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
    * @param component the component that uses this HTML template, not `null`
    * @param application the Angular application to resolve in context of
    */
-  ResolveAngularComponentTemplateTask(InternalAnalysisContext context, this.source, AngularComponentElement component, AngularApplicationInfo application) : super(context) {
+  ResolveAngularComponentTemplateTask(InternalAnalysisContext context, this.source, AngularComponentElement component, AngularApplication application) : super(context) {
     this._component = component;
     this._application = application;
   }
 
   accept(AnalysisTaskVisitor visitor) => visitor.visitResolveAngularComponentTemplateTask(this);
 
   /**
    * Return the time at which the contents of the source that was parsed were last modified, or a
    * negative value if the task has not yet been performed or if an exception occurred.
    *
@@ skipping 16 matching lines @@
     ResolvableHtmlUnit resolvableHtmlUnit = context.computeResolvableAngularComponentHtmlUnit(source);
     ht.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;
     // prepare for resolution
     RecordingErrorListener errorListener = new RecordingErrorListener();
     LineInfo lineInfo = context.getLineInfo(source);
     // do resolve
-    AngularHtmlUnitResolver resolver = new AngularHtmlUnitResolver(context, errorListener, source, lineInfo, unit);
-    resolver.resolveComponentTemplate(_application, _component);
+    if (_application != null) {
+      AngularHtmlUnitResolver resolver = new AngularHtmlUnitResolver(context, errorListener, source, lineInfo, unit);
+      resolver.resolveComponentTemplate(_application, _component);
+      _resolvedUnit = unit;
+    }
     // remember errors
     _resolutionErrors = errorListener.getErrors2(source);
-    // remember resolved unit
-    _resolvedUnit = unit;
   }
 }
 
 /**
  * Instances of the class `ResolveAngularEntryHtmlTask` resolve a specific HTML file as an
  * Angular entry point.
  */
 class ResolveAngularEntryHtmlTask extends AnalysisTask {
   /**
    * The source to be resolved.
    */
   final Source source;
 
   /**
-   * The Angular application to resolve in context of.
+   * The listener to record errors.
    */
-  AngularApplicationInfo _application;
+  RecordingErrorListener _errorListener = new RecordingErrorListener();
 
   /**
    * The time at which the contents of the source were last modified.
    */
   int _modificationTime = -1;
 
   /**
    * The [HtmlUnit] that was resolved by this task.
    */
   ht.HtmlUnit _resolvedUnit;
 
   /**
    * The element produced by resolving the source.
    */
   HtmlElement _element = null;
 
   /**
-   * The resolution errors that were discovered while resolving the source.
+   * The Angular application to resolve in context of.
    */
-  List<AnalysisError> _resolutionErrors = AnalysisError.NO_ERRORS;
+  AngularApplication _application;
 
   /**
    * 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
-   * @param application the Angular application to resolve in context of
    */
-  ResolveAngularEntryHtmlTask(InternalAnalysisContext context, this.source, AngularApplicationInfo application) : super(context) {
-    this._application = application;
-  }
+  ResolveAngularEntryHtmlTask(InternalAnalysisContext context, this.source) : super(context);
 
   accept(AnalysisTaskVisitor visitor) => visitor.visitResolveAngularEntryHtmlTask(this);
 
+  /**
+   * Returns the [AngularApplication] for the Web application with this Angular entry point,
+   * maybe `null` if not an Angular entry point.
+   */
+  AngularApplication get application => _application;
+
   HtmlElement get element => _element;
 
   /**
+   * The resolution errors that were discovered while resolving the source.
+   */
+  List<AnalysisError> get entryErrors => _errorListener.getErrors2(source);
+
+  /**
+   * Returns [AnalysisError]s recorded for the given [Source].
+   */
+  List<AnalysisError> getErrors(Source source) => _errorListener.getErrors2(source);
+
+  /**
    * Return the time at which the contents of the source that was parsed were last modified, or a
    * negative value if the task has not yet been performed or if an exception occurred.
    *
    * @return the time at which the contents of the source that was parsed were last modified
    */
   int get modificationTime => _modificationTime;
 
-  List<AnalysisError> get resolutionErrors => _resolutionErrors;
-
   /**
    * Return the [HtmlUnit] that was resolved by this task.
    *
    * @return the [HtmlUnit] that was resolved by this task
    */
   ht.HtmlUnit get resolvedUnit => _resolvedUnit;
 
   String get taskDescription {
     if (source == null) {
       return "resolve as Angular entry point null source";
     }
     return "resolve as Angular entry point ${source.fullName}";
   }
 
   void internalPerform() {
     ResolvableHtmlUnit resolvableHtmlUnit = context.computeResolvableAngularComponentHtmlUnit(source);
     ht.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;
     // prepare for resolution
-    RecordingErrorListener errorListener = new RecordingErrorListener();
     LineInfo lineInfo = context.getLineInfo(source);
+    // try to resolve as an Angular entry point
+    _application = new AngularHtmlUnitResolver(context, _errorListener, source, lineInfo, unit).calculateAngularApplication();
     // do resolve
-    new AngularHtmlUnitResolver(context, errorListener, source, lineInfo, unit).resolveEntryPoint(_application);
-    // remember errors
-    _resolutionErrors = errorListener.getErrors2(source);
+    if (_application != null) {
+      new AngularHtmlUnitResolver(context, _errorListener, source, lineInfo, unit).resolveEntryPoint(_application);
+    }
     // remember resolved unit
     _resolvedUnit = unit;
   }
 }
 
 /**
  * Instances of the class `ResolveDartDependenciesTask` resolve the import, export, and part
  * directives in a single source.
  */
 class ResolveDartDependenciesTask extends AnalysisTask {
@@ skipping 65 matching lines @@
   int get modificationTime => _modificationTime;
 
   String get taskDescription {
     if (source == null) {
       return "resolve dart dependencies null source";
     }
     return "resolve dart dependencies ${source.fullName}";
   }
 
   void internalPerform() {
-    ResolvableCompilationUnit unit = context.computeResolvableCompilationUnit(source);
+    TimestampedData<CompilationUnit> unit = context.internalParseCompilationUnit(source);
     _modificationTime = unit.modificationTime;
-    //
-    // Then parse the token stream.
-    //
     TimeCounter_TimeCounterHandle timeCounterParse = PerformanceStatistics.parse.start();
     try {
-      for (Directive directive in unit.compilationUnit.directives) {
+      for (Directive directive in unit.data.directives) {
         if (directive is ExportDirective) {
           Source exportSource = resolveSource(source, directive);
           if (exportSource != null) {
             _exportedSources.add(exportSource);
           }
         } else if (directive is ImportDirective) {
           Source importSource = resolveSource(source, directive);
           if (importSource != null) {
             _importedSources.add(importSource);
           }
@@ skipping 263 matching lines @@
    * 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;
 
   /**
-   * The flag that says is this unit is an Angular application.
-   */
-  bool _isAngularApplication2 = false;
-
-  /**
-   * The Angular application information, maybe `null`
-   */
-  AngularApplicationInfo _angularApplication;
-
-  /**
    * 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, this.source) : super(context);
 
   accept(AnalysisTaskVisitor visitor) => visitor.visitResolveHtmlTask(this);
 
-  /**
-   * Returns the [AngularApplicationInfo] for the Web application with this Angular entry
-   * point, maybe `null` if not an Angular entry point.
-   */
-  AngularApplicationInfo get angularApplication => _angularApplication;
-
   HtmlElement get element => _element;
 
   /**
    * Return the time at which the contents of the source that was parsed were last modified, or a
    * negative value if the task has not yet been performed or if an exception occurred.
    *
    * @return the time at which the contents of the source that was parsed were last modified
    */
   int get modificationTime => _modificationTime;
 
   List<AnalysisError> get resolutionErrors => _resolutionErrors;
 
   /**
    * Return the [HtmlUnit] that was resolved by this task.
    *
    * @return the [HtmlUnit] that was resolved by this task
    */
   ht.HtmlUnit get resolvedUnit => _resolvedUnit;
 
-  /**
-   * Returns `true` if analyzed unit is an Angular application.
-   */
-  bool get isAngularApplication => _isAngularApplication2;
-
   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);
     ht.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;
     // build standard HTML element
     HtmlUnitBuilder builder = new HtmlUnitBuilder(context);
     _element = builder.buildHtmlElement2(source, _modificationTime, unit);
     RecordingErrorListener errorListener = builder.errorListener;
-    LineInfo lineInfo = context.getLineInfo(source);
-    // try to resolve as an Angular entry point
-    if (context.analysisOptions.analyzeAngular) {
-      _isAngularApplication2 = AngularHtmlUnitResolver.hasAngularAnnotation(unit);
-      _angularApplication = new AngularHtmlUnitResolver(context, errorListener, source, lineInfo, unit).calculateAngularApplication();
-    }
     // record all resolution errors
     _resolutionErrors = errorListener.getErrors2(source);
     // remember resolved unit
     _resolvedUnit = unit;
   }
 }
 
 /**
+ * Instances of the class `ScanDartTask` scan a specific source as a Dart file.
+ */
+class ScanDartTask extends AnalysisTask {
+  /**
+   * The source to be scanned.
+   */
+  final Source source;
+
+  /**
+   * The contents of the source.
+   */
+  String _content;
+
+  /**
+   * The time at which the contents of the source were last modified.
+   */
+  int _modificationTime = 0;
+
+  /**
+   * The token stream that was produced by scanning the source.
+   */
+  Token _tokenStream;
+
+  /**
+   * The line information that was produced.
+   */
+  LineInfo _lineInfo;
+
+  /**
+   * The errors that were produced by scanning the source.
+   */
+  List<AnalysisError> _errors = 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 parsed
+   * @param contentData the time-stamped contents of the source
+   */
+  ScanDartTask(InternalAnalysisContext context, this.source, TimestampedData<String> contentData) : super(context) {
+    this._content = contentData.data;
+    this._modificationTime = contentData.modificationTime;
+  }
+
+  accept(AnalysisTaskVisitor visitor) => visitor.visitScanDartTask(this);
+
+  /**
+   * Return the errors that were produced by scanning the source, or `null` if the task has
+   * not yet been performed or if an exception occurred.
+   *
+   * @return the errors that were produced by scanning the source
+   */
+  List<AnalysisError> get errors => _errors;
+
+  /**
+   * Return the line information that was produced, or `null` if the task has not yet been
+   * performed or if an exception occurred.
+   *
+   * @return the line information that was produced
+   */
+  LineInfo get lineInfo => _lineInfo;
+
+  /**
+   * Return the time at which the contents of the source that was parsed were last modified, or a
+   * negative value if the task has not yet been performed or if an exception occurred.
+   *
+   * @return the time at which the contents of the source that was parsed were last modified
+   */
+  int get modificationTime => _modificationTime;
+
+  /**
+   * Return the token stream that was produced by scanning the source, or `null` if the task
+   * has not yet been performed or if an exception occurred.
+   *
+   * @return the token stream that was produced by scanning the source
+   */
+  Token get tokenStream => _tokenStream;
+
+  String get taskDescription {
+    if (source == null) {
+      return "scan as dart null source";
+    }
+    return "scan as dart ${source.fullName}";
+  }
+
+  void internalPerform() {
+    RecordingErrorListener errorListener = new RecordingErrorListener();
+    TimeCounter_TimeCounterHandle timeCounterScan = PerformanceStatistics.scan.start();
+    try {
+      Scanner scanner = new Scanner(source, new CharSequenceReader(_content), errorListener);
+      scanner.preserveComments = context.analysisOptions.preserveComments;
+      _tokenStream = scanner.tokenize();
+      _lineInfo = new LineInfo(scanner.lineStarts);
+      _errors = errorListener.getErrors2(source);
+    } on JavaException catch (exception) {
+      throw new AnalysisException.con3(exception);
+    } finally {
+      timeCounterScan.stop();
+    }
+  }
+}
+
+/**
  * 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 38 matching lines @@
 
   void logError2(String message, Exception exception) {
   }
 
   void logInformation(String message) {
   }
 
   void logInformation3(String message, Exception exception) {
   }
 }