New analzyer 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 1309 matching lines @@
 
   CacheState(String name, int ordinal) : super(name, ordinal);
 }
 
 /**
  * The interface `DartEntry` defines the behavior of objects that maintain the information
  * cached by an analysis context about an individual Dart file.
  */
 abstract class DartEntry implements SourceEntry {
   /**
+   * The data descriptor representing the errors reported during Angular resolution.
+   */
+  static final DataDescriptor<List<AnalysisError>> ANGULAR_ERRORS = new DataDescriptor<List<AnalysisError>>("DartEntry.ANGULAR_ERRORS");
+
+  /**
    * The data descriptor representing the list of libraries that contain this compilation unit.
    */
   static final DataDescriptor<List<Source>> CONTAINING_LIBRARIES = new DataDescriptor<List<Source>>("DartEntry.CONTAINING_LIBRARIES");
 
   /**
    * The data descriptor representing the library element for the library. This data is only
    * available for Dart files that are the defining compilation unit of a library.
    */
   static final DataDescriptor<LibraryElement> ELEMENT = new DataDescriptor<LibraryElement>("DartEntry.ELEMENT");
 
@@ skipping 52 matching lines @@
    * The data descriptor representing the errors resulting from resolving the source.
    */
   static final DataDescriptor<List<AnalysisError>> RESOLUTION_ERRORS = new DataDescriptor<List<AnalysisError>>("DartEntry.RESOLUTION_ERRORS");
 
   /**
    * The data descriptor representing the resolved AST structure.
    */
   static final DataDescriptor<CompilationUnit> RESOLVED_UNIT = new DataDescriptor<CompilationUnit>("DartEntry.RESOLVED_UNIT");
 
   /**
+   * 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 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 529 matching lines @@
     while (state != null) {
       CacheState resolvedState = state._resolvedUnitState;
       if (resolvedState != CacheState.VALID && resolvedState != CacheState.FLUSHED) {
         return false;
       }
       state = state._nextState;
     }
     return true;
   }
 
+  void recordContentError() {
+    super.recordContentError();
+    recordScanError();
+  }
+
   /**
    * Record that an error occurred while attempting to resolve the directives in the source
    * represented by this entry.
    */
   void recordDependencyError() {
     _exportedLibraries = Source.EMPTY_ARRAY;
     _exportedLibrariesState = CacheState.ERROR;
     _importedLibraries = Source.EMPTY_ARRAY;
     _importedLibrariesState = CacheState.ERROR;
     _includedParts = Source.EMPTY_ARRAY;
@@ skipping 1033 matching lines @@
     _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;
   }
 
+  void recordContentError() {
+    super.recordContentError();
+    recordParseError();
+  }
+
   /**
    * Record that an error was encountered while attempting to parse the source associated with this
    * entry.
    */
   void recordParseError() {
     setState(SourceEntry.LINE_INFO, CacheState.ERROR);
     setState(HtmlEntry.PARSE_ERRORS, CacheState.ERROR);
     setState(HtmlEntry.PARSED_UNIT, CacheState.ERROR);
     setState(HtmlEntry.REFERENCED_LIBRARIES, CacheState.ERROR);
     recordResolutionError();
@@ skipping 175 matching lines @@
 
 /**
  * The interface `SourceEntry` defines the behavior of objects that maintain the information
  * cached by an analysis context about an individual source, no matter what kind of source it is.
  *
  * Source entries should be treated as if they were immutable unless a writable copy of the entry
  * has been obtained and has not yet been made visible to other threads.
  */
 abstract class SourceEntry {
   /**
+   * The data descriptor representing the contents of the source.
+   */
+  static final DataDescriptor<String> CONTENT = new DataDescriptor<String>("DartEntry.CONTENT");
+
+  /**
    * The data descriptor representing the line information.
    */
   static final DataDescriptor<LineInfo> LINE_INFO = new DataDescriptor<LineInfo>("SourceEntry.LINE_INFO");
 
   /**
    * Return the exception that caused one or more values to have a state of [CacheState#ERROR]
    * .
    *
    * @return the exception that caused one or more values to be uncomputable
    */
@@ skipping 50 matching lines @@
    * entry.
    */
   int _modificationTime = 0;
 
   /**
    * The exception that caused one or more values to have a state of [CacheState#ERROR].
    */
   AnalysisException exception;
 
   /**
+   * The state of the cached content.
+   */
+  CacheState _contentState = CacheState.INVALID;
+
+  /**
+   * The content of the source, or `null` if the content is not currently cached.
+   */
+  String _content;
+
+  /**
    * The state of the cached line information.
    */
   CacheState _lineInfoState = CacheState.INVALID;
 
   /**
    * The line information computed for the source, or `null` if the line information is not
    * currently cached.
    */
   LineInfo _lineInfo;
 
@@ skipping 10 matching lines @@
         exception = new AnalysisException.con1("State set to ERROR without setting an exception");
       }
     } else {
       exception = null;
     }
   }
 
   int get modificationTime => _modificationTime;
 
   CacheState getState(DataDescriptor descriptor) {
-    if (identical(descriptor, SourceEntry.LINE_INFO)) {
+    if (identical(descriptor, SourceEntry.CONTENT)) {
+      return _contentState;
+    } else if (identical(descriptor, SourceEntry.LINE_INFO)) {
       return _lineInfoState;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
 
   Object getValue(DataDescriptor descriptor) {
-    if (identical(descriptor, SourceEntry.LINE_INFO)) {
+    if (identical(descriptor, SourceEntry.CONTENT)) {
+      return _content;
+    } else if (identical(descriptor, SourceEntry.LINE_INFO)) {
       return _lineInfo;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
 
   /**
    * Invalidate all of the information associated with this source.
    */
   void invalidateAllInformation() {
+    _content = null;
+    _contentState = CacheState.INVALID;
     _lineInfo = null;
     _lineInfoState = CacheState.INVALID;
   }
 
   /**
+   * Record that an error occurred while attempting to get the contents of the source represented by
+   * this entry. This will set the state of all information, including any resolution-based
+   * information, as being in error.
+   */
+  void recordContentError() {
+    _content = null;
+    _contentState = CacheState.ERROR;
+  }
+
+  /**
    * Set the most recent time at which the state of the source matched the state represented by this
    * entry to the given time.
    *
    * @param time the new modification time of this entry
    */
   void set modificationTime(int time) {
     _modificationTime = time;
   }
 
   /**
    * Set the state of the data represented by the given descriptor to the given state.
    *
    * @param descriptor the descriptor representing the data whose state is to be set
    * @param the new state of the data represented by the given descriptor
    */
   void setState(DataDescriptor descriptor, CacheState state) {
-    if (identical(descriptor, SourceEntry.LINE_INFO)) {
+    if (identical(descriptor, SourceEntry.CONTENT)) {
+      _content = updatedValue(state, _content, null);
+      _contentState = state;
+    } else if (identical(descriptor, SourceEntry.LINE_INFO)) {
       _lineInfo = updatedValue(state, _lineInfo, null);
       _lineInfoState = state;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
 
   /**
    * Set the value of the data represented by the given descriptor to the given value.
    *
    * @param descriptor the descriptor representing the data whose value is to be set
    * @param value the new value of the data represented by the given descriptor
    */
   void setValue(DataDescriptor descriptor, Object value) {
-    if (identical(descriptor, SourceEntry.LINE_INFO)) {
+    if (identical(descriptor, SourceEntry.CONTENT)) {
+      _content = value as String;
+      _contentState = CacheState.VALID;
+    } else if (identical(descriptor, SourceEntry.LINE_INFO)) {
       _lineInfo = value as LineInfo;
       _lineInfoState = CacheState.VALID;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
 
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
     writeOn(builder);
     return builder.toString();
   }
 
   /**
    * Copy the information from the given cache entry.
    *
    * @param entry the cache entry from which information will be copied
    */
   void copyFrom(SourceEntryImpl entry) {
     _modificationTime = entry._modificationTime;
     exception = entry.exception;
+    _contentState = entry._contentState;
+    _content = entry._content;
     _lineInfoState = entry._lineInfoState;
     _lineInfo = entry._lineInfo;
   }
 
   /**
    * Return `true` if the state of any data value is [CacheState#ERROR].
    *
    * @return `true` if the state of any data value is [CacheState#ERROR]
    */
-  bool hasErrorState() => identical(_lineInfoState, CacheState.ERROR);
+  bool hasErrorState() => identical(_contentState, CacheState.ERROR) || identical(_lineInfoState, CacheState.ERROR);
 
   /**
    * Given that some data is being transitioned to the given state, return the value that should be
    * kept in the cache.
    *
    * @param state the state to which the data is being transitioned
    * @param currentValue the value of the data before the transition
    * @param defaultValue the value to be used if the current value is to be removed from the cache
    * @return the value of the data that should be kept in the cache
    */
@@ skipping 10 matching lines @@
   }
 
   /**
    * Write a textual representation of this entry to the given builder. The result will only be used
    * for debugging purposes.
    *
    * @param builder the builder to which the text should be written
    */
   void writeOn(JavaStringBuilder builder) {
     builder.append("time = ");
-    builder.append(_modificationTime.toRadixString(16));
+    builder.append(_modificationTime);
+    builder.append("; content = ");
+    builder.append(_contentState);
     builder.append("; lineInfo = ");
     builder.append(_lineInfoState);
   }
 }
 
 /**
  * Implementation of the [AnalysisContentStatistics].
  */
 class AnalysisContentStatisticsImpl implements AnalysisContentStatistics {
   Map<String, AnalysisContentStatistics_CacheRow> _dataMap = new Map<String, AnalysisContentStatistics_CacheRow>();
@@ skipping 402 matching lines @@
       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;
+    {
+      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
@@ skipping 22 matching lines @@
       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);
+    {
+      String contents = _contentCache.getContents(source);
+      if (contents != null) {
+        return new TimestampedData<String>(_contentCache.getModificationStamp(source), contents);
+      }
     }
     return source.contents;
   }
 
   void getContentsToReceiver(Source source, Source_ContentReceiver receiver) {
-    String contents = _contentCache.getContents(source);
-    if (contents != null) {
-      receiver.accept(contents, _contentCache.getModificationStamp(source));
-      return;
+    {
+      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;
@@ skipping 146 matching lines @@
 
   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;
+    {
+      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) {
@@ skipping 365 matching lines @@
   void setChangedContents(Source source, String contents, int offset, int oldLength, int newLength) {
     {
       _recentTasks.clear();
       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);
+          SourceEntry sourceEntry = _cache.get(source);
+          if (sourceEntry != null) {
+            SourceEntryImpl sourceCopy = sourceEntry.writableCopy;
+            sourceCopy.modificationTime = _contentCache.getModificationStamp(source);
+            sourceCopy.setValue(SourceEntry.CONTENT, contents);
+            _cache.put(source, sourceCopy);
+          }
         }
       } else if (originalContents != null) {
         _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
         sourceChanged(source);
       }
     }
   }
 
   void setContents(Source source, String contents) {
     {
       _recentTasks.clear();
       String originalContents = _contentCache.setContents(source, contents);
       if (contents != null) {
         if (contents != originalContents) {
           _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
           sourceChanged(source);
+          SourceEntry sourceEntry = _cache.get(source);
+          if (sourceEntry != null) {
+            SourceEntryImpl sourceCopy = sourceEntry.writableCopy;
+            sourceCopy.modificationTime = _contentCache.getModificationStamp(source);
+            sourceCopy.setValue(SourceEntry.CONTENT, contents);
+            _cache.put(source, sourceCopy);
+          }
         }
       } else if (originalContents != null) {
         _incrementalAnalysisCache = IncrementalAnalysisCache.clear(_incrementalAnalysisCache, source);
         sourceChanged(source);
       }
     }
   }
 
   void set sourceFactory(SourceFactory factory) {
     {
@@ skipping 415 matching lines @@
     }
     //
     // Check to see whether we already have the information being requested.
     //
     CacheState state = htmlEntry.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.
       //
-      htmlEntry = new ParseHtmlTask(this, source).perform(_resultRecorder) as HtmlEntry;
+      // TODO(brianwilkerson) Convert this to get the contents from the cache. (I'm not sure how
+      // that would work in an asynchronous environment.)
+      try {
+        htmlEntry = new ParseHtmlTask(this, source, getContents(source)).perform(_resultRecorder) as HtmlEntry;
+      } on AnalysisException catch (exception) {
+        throw exception;
+      } on JavaException catch (exception) {
+        throw new AnalysisException.con3(exception);
+      }
       state = htmlEntry.getState(descriptor);
     }
     return htmlEntry;
   }
 
   /**
    * Given a source for an HTML file, return a cache entry in which the state of the data
    * represented by the given descriptor is either [CacheState#VALID] or
    * [CacheState#ERROR]. This method assumes that the data can be produced by resolving the
    * source if it is not already cached.
@@ skipping 406 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;
+      bool hasBlockedTask = false;
       //
       // 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, sdkErrorsEnabled);
+        AnalysisContextImpl_TaskData taskData = getNextNondependentAnalysisTask(source, hintsEnabled, sdkErrorsEnabled);
+        AnalysisTask task = taskData.task;
         if (task != null) {
           return task;
+        } else if (taskData.isBlocked) {
+          hasBlockedTask = true;
         }
       }
       //
       // 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, sdkErrorsEnabled);
+        AnalysisContextImpl_TaskData taskData = getNextNondependentAnalysisTask(source, hintsEnabled, sdkErrorsEnabled);
+        AnalysisTask task = taskData.task;
         if (task != null) {
           return task;
+        } else if (taskData.isBlocked) {
+          hasBlockedTask = true;
+        } else {
+          _workManager.remove(source);
         }
-        _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()) {
       //        source = entry.getKey();
-      //        AnalysisTask task = getNextAnalysisTask(source, entry.getValue(), false, hintsEnabled);
+      //        TaskData taskData = getNextAnalysisTaskForSource(source, entry.getValue(), false, hintsEnabled);
+      //        AnalysisTask task = taskData.getTask();
       //        if (task != null) {
       //          System.out.println("Failed to analyze " + source.getFullName());
       //          return task;
       //        }
       //      }
+      if (hasBlockedTask) {
+        return WaitForAsyncTask.instance;
+      }
       return null;
     }
   }
 
   /**
    * 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, bool sdkErrorsEnabled) {
+  AnalysisContextImpl_TaskData getNextAnalysisTaskForSource(Source source, SourceEntry sourceEntry, bool isPriority, bool hintsEnabled, bool sdkErrorsEnabled) {
+    if (sourceEntry == null) {
+      return new AnalysisContextImpl_TaskData(null, false, null);
+    }
+    CacheState contentState = sourceEntry.getState(SourceEntry.CONTENT);
+    if (identical(contentState, CacheState.INVALID)) {
+      SourceEntryImpl sourceCopy = sourceEntry.writableCopy;
+      sourceCopy.setState(SourceEntry.CONTENT, CacheState.IN_PROCESS);
+      _cache.put(source, sourceCopy);
+      return new AnalysisContextImpl_TaskData(new GetContentTask(this, source), false, null);
+    } else if (identical(contentState, CacheState.IN_PROCESS)) {
+      // We are in the process of getting the content. There's nothing else we can do with this
+      // source until that's complete.
+      return new AnalysisContextImpl_TaskData(null, true, null);
+    }
     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);
+          TimestampedData<String> contentData;
+          if (identical(contentState, CacheState.VALID)) {
+            contentData = new TimestampedData<String>(dartCopy.modificationTime, dartCopy.getValue(SourceEntry.CONTENT));
+            dartCopy.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
+          } else {
+            contentData = getContents(source);
+          }
           _cache.put(source, dartCopy);
-          return new ScanDartTask(this, source, getContents(source));
+          return new AnalysisContextImpl_TaskData(new ScanDartTask(this, source, contentData), false, null);
         } 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);
+        return new AnalysisContextImpl_TaskData(new ParseDartTask(this, source), false, null);
       }
       if (isPriority && parseErrorsState != CacheState.ERROR) {
         CompilationUnit parseUnit = dartEntry.anyParsedCompilationUnit;
         if (parseUnit == null) {
           DartEntryImpl dartCopy = dartEntry.writableCopy;
           dartCopy.setState(DartEntry.PARSED_UNIT, CacheState.IN_PROCESS);
           _cache.put(source, dartCopy);
-          return new ParseDartTask(this, source);
+          return new AnalysisContextImpl_TaskData(new ParseDartTask(this, source), false, null);
         }
       }
       CacheState exportState = dartEntry.getState(DartEntry.EXPORTED_LIBRARIES);
       if (identical(exportState, CacheState.INVALID) || (isPriority && identical(exportState, CacheState.FLUSHED))) {
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         dartCopy.setState(DartEntry.EXPORTED_LIBRARIES, CacheState.IN_PROCESS);
         _cache.put(source, dartCopy);
-        return new ResolveDartDependenciesTask(this, source);
+        return new AnalysisContextImpl_TaskData(new ResolveDartDependenciesTask(this, source), false, null);
       }
       List<Source> librariesContaining = dartEntry.getValue(DartEntry.CONTAINING_LIBRARIES);
       for (Source librarySource in librariesContaining) {
         SourceEntry libraryEntry = _cache.get(librarySource);
         if (libraryEntry is DartEntry) {
           CacheState elementState = libraryEntry.getState(DartEntry.ELEMENT);
           if (identical(elementState, CacheState.INVALID) || (isPriority && identical(elementState, CacheState.FLUSHED))) {
             DartEntryImpl libraryCopy = libraryEntry.writableCopy;
             libraryCopy.setState(DartEntry.ELEMENT, CacheState.IN_PROCESS);
             _cache.put(librarySource, libraryCopy);
-            return new ResolveDartLibraryTask(this, source, librarySource);
+            return new AnalysisContextImpl_TaskData(new ResolveDartLibraryTask(this, source, librarySource), false, null);
           }
           CacheState resolvedUnitState = dartEntry.getState2(DartEntry.RESOLVED_UNIT, librarySource);
           if (identical(resolvedUnitState, CacheState.INVALID) || (isPriority && identical(resolvedUnitState, CacheState.FLUSHED))) {
             //
             // The commented out lines below are an optimization that doesn't quite work yet. The
             // problem is that if the source was not resolved because it wasn't part of any library,
             // 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);
+            return new AnalysisContextImpl_TaskData(new ResolveDartLibraryTask(this, source, librarySource), false, null);
           }
           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.VERIFICATION_ERRORS, librarySource, CacheState.IN_PROCESS);
                 _cache.put(source, dartCopy);
-                return new GenerateDartErrorsTask(this, source, libraryElement);
+                return new AnalysisContextImpl_TaskData(new GenerateDartErrorsTask(this, source, libraryElement), false, null);
               }
             }
             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);
+                  return new AnalysisContextImpl_TaskData(new GenerateDartHintsTask(this, libraryElement), false, null);
                 }
               }
             }
           }
         }
       }
     } 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;
-        dartCopy.setState(HtmlEntry.PARSE_ERRORS, CacheState.IN_PROCESS);
-        _cache.put(source, dartCopy);
-        return new ParseHtmlTask(this, source);
+        try {
+          HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
+          htmlCopy.setState(HtmlEntry.PARSE_ERRORS, CacheState.IN_PROCESS);
+          TimestampedData<String> contentData;
+          if (identical(contentState, CacheState.VALID)) {
+            contentData = new TimestampedData<String>(htmlCopy.modificationTime, htmlCopy.getValue(SourceEntry.CONTENT));
+            htmlCopy.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
+          } else {
+            contentData = getContents(source);
+          }
+          _cache.put(source, htmlCopy);
+          return new AnalysisContextImpl_TaskData(new ParseHtmlTask(this, source, contentData), false, null);
+        } on JavaException catch (exception) {
+          HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
+          htmlCopy.recordParseError();
+          htmlCopy.exception = new AnalysisException.con3(exception);
+          _cache.put(source, htmlCopy);
+        }
       }
       if (isPriority && parseErrorsState != CacheState.ERROR) {
         ht.HtmlUnit parsedUnit = htmlEntry.anyParsedUnit;
         if (parsedUnit == null) {
-          HtmlEntryImpl dartCopy = htmlEntry.writableCopy;
-          dartCopy.setState(HtmlEntry.PARSED_UNIT, CacheState.IN_PROCESS);
-          _cache.put(source, dartCopy);
-          return new ParseHtmlTask(this, source);
+          try {
+            HtmlEntryImpl dartCopy = htmlEntry.writableCopy;
+            dartCopy.setState(HtmlEntry.PARSE_ERRORS, CacheState.IN_PROCESS);
+            TimestampedData<String> contentData;
+            if (identical(contentState, CacheState.VALID)) {
+              contentData = new TimestampedData<String>(dartCopy.modificationTime, dartCopy.getValue(SourceEntry.CONTENT));
+              dartCopy.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
+            } else {
+              contentData = getContents(source);
+            }
+            _cache.put(source, dartCopy);
+            return new AnalysisContextImpl_TaskData(new ParseHtmlTask(this, source, contentData), false, null);
+          } on JavaException catch (exception) {
+            HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
+            htmlCopy.recordParseError();
+            htmlCopy.exception = new AnalysisException.con3(exception);
+            _cache.put(source, htmlCopy);
+          }
         }
       }
       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);
+        return new AnalysisContextImpl_TaskData(new ResolveHtmlTask(this, source), false, null);
       }
       // 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);
+          return new AnalysisContextImpl_TaskData(new ResolveAngularEntryHtmlTask(this, source), false, null);
         }
         // try to resolve as an Angular application part
         CacheState angularErrorsState = htmlEntry.getState(HtmlEntry.ANGULAR_ERRORS);
         if (identical(angularErrorsState, CacheState.INVALID)) {
           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.setState(HtmlEntry.ANGULAR_ERRORS, CacheState.IN_PROCESS);
           _cache.put(source, htmlCopy);
-          return new ResolveAngularComponentTemplateTask(this, source, component, application);
+          return new AnalysisContextImpl_TaskData(new ResolveAngularComponentTemplateTask(this, source, component, application), false, null);
         }
       }
     }
-    return null;
+    return new AnalysisContextImpl_TaskData(null, false, null);
+  }
+
+  AnalysisContextImpl_TaskData getNextNondependentAnalysisTask(Source source, bool hintsEnabled, bool sdkErrorsEnabled) {
+    AnalysisContextImpl_TaskData taskData = getNextAnalysisTaskForSource(source, _cache.get(source), true, hintsEnabled, sdkErrorsEnabled);
+    if (taskData.task != null || taskData.isBlocked) {
+      return taskData;
+    }
+    while (taskData.dependentSource != null) {
+      taskData = getNextAnalysisTaskForSource(source, _cache.get(source), true, hintsEnabled, sdkErrorsEnabled);
+      if (taskData.task != null || taskData.isBlocked) {
+        return taskData;
+      }
+    }
+    return new AnalysisContextImpl_TaskData(null, false, 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
    * @return a change notice for the given source
    */
   ChangeNoticeImpl getNotice(Source source) {
     ChangeNoticeImpl notice = _pendingNotices[source];
@@ skipping 627 matching lines @@
         }
       }
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return libraryEntry;
   }
 
   /**
+   * Record the results produced by performing a [GetContentTask].
+   *
+   * @param task the task that was performed
+   * @return an entry containing the computed results
+   * @throws AnalysisException if the results could not be recorded
+   */
+  SourceEntry recordGetContentsTask(GetContentTask task) {
+    if (!task.isComplete) {
+      return null;
+    }
+    Source source = task.source;
+    AnalysisException thrownException = task.exception;
+    SourceEntry sourceEntry = null;
+    {
+      sourceEntry = _cache.get(source);
+      if (sourceEntry == null) {
+        throw new ObsoleteSourceAnalysisException(source);
+      }
+      SourceEntryImpl sourceCopy = sourceEntry.writableCopy;
+      if (thrownException == null) {
+        sourceCopy.modificationTime = task.modificationTime;
+        sourceCopy.setValue(SourceEntry.CONTENT, task.content);
+      } else {
+        sourceCopy.exception = thrownException;
+        sourceCopy.recordContentError();
+        _workManager.remove(source);
+      }
+      _cache.put(source, sourceCopy);
+      sourceEntry = sourceCopy;
+    }
+    if (thrownException != null) {
+      throw thrownException;
+    }
+    return sourceEntry;
+  }
+
+  /**
    * Record the results produced by performing a [IncrementalAnalysisTask].
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   DartEntry recordIncrementalAnalysisTaskResults(IncrementalAnalysisTask task) {
     {
       CompilationUnit unit = task.compilationUnit;
       if (unit != null) {
@@ skipping 449 matching lines @@
   }
 
   /**
    * Record the results produced by performing a [ResolveDartUnitTask]. 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
    */
-  SourceEntry recordResolveDartUnitTaskResults(ResolveDartUnitTask task) {
+  DartEntry 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 == 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
@@ skipping 59 matching lines @@
   }
 
   /**
    * Record the results produced by performing a [ResolveHtmlTask]. If the results were
    * computed from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
-  SourceEntry recordResolveHtmlTaskResults(ResolveHtmlTask task) {
+  HtmlEntry recordResolveHtmlTaskResults(ResolveHtmlTask task) {
     Source source = task.source;
     AnalysisException thrownException = task.exception;
     HtmlEntry htmlEntry = null;
     {
       SourceEntry sourceEntry = _cache.get(source);
       if (sourceEntry == null) {
         throw new ObsoleteSourceAnalysisException(source);
       } else if (sourceEntry is! HtmlEntry) {
         // This shouldn't be possible because we should never have performed the task if the source
         // didn't represent an HTML file, but check to be safe.
@@ skipping 158 matching lines @@
    * @param dartEntry the entry containing the list of included parts
    */
   void removeFromParts(Source librarySource, DartEntry dartEntry) {
     List<Source> oldParts = dartEntry.getValue(DartEntry.INCLUDED_PARTS);
     for (int i = 0; i < oldParts.length; i++) {
       Source partSource = oldParts[i];
       DartEntry partEntry = getReadableDartEntry(partSource);
       if (partEntry != null && partEntry != dartEntry) {
         DartEntryImpl partCopy = partEntry.writableCopy;
         partCopy.removeContainingLibrary(librarySource);
-        _cache.put(partSource, partCopy);
+        if (partCopy.librariesContaining.length == 0 && !exists(partSource)) {
+          _cache.remove(partSource);
+        } else {
+          _cache.put(partSource, partCopy);
+        }
       }
     }
   }
 
   /**
    * Remove the given source from the priority order if it is in the list.
    *
    * @param source the source to be removed
    */
   void removeFromPriorityOrder(Source source) {
@@ skipping 174 matching lines @@
 
 /**
  * Instances of the class `AnalysisTaskResultRecorder` are used by an analysis context to
  * record the results of a task.
  */
 class AnalysisContextImpl_AnalysisTaskResultRecorder implements AnalysisTaskVisitor<SourceEntry> {
   final AnalysisContextImpl AnalysisContextImpl_this;
 
   AnalysisContextImpl_AnalysisTaskResultRecorder(this.AnalysisContextImpl_this);
 
-  SourceEntry visitGenerateDartErrorsTask(GenerateDartErrorsTask task) => AnalysisContextImpl_this.recordGenerateDartErrorsTask(task);
+  DartEntry visitGenerateDartErrorsTask(GenerateDartErrorsTask task) => AnalysisContextImpl_this.recordGenerateDartErrorsTask(task);
 
-  SourceEntry visitGenerateDartHintsTask(GenerateDartHintsTask task) => AnalysisContextImpl_this.recordGenerateDartHintsTask(task);
+  DartEntry visitGenerateDartHintsTask(GenerateDartHintsTask task) => AnalysisContextImpl_this.recordGenerateDartHintsTask(task);
 
-  SourceEntry visitIncrementalAnalysisTask(IncrementalAnalysisTask task) => AnalysisContextImpl_this.recordIncrementalAnalysisTaskResults(task);
+  SourceEntry visitGetContentTask(GetContentTask task) => AnalysisContextImpl_this.recordGetContentsTask(task);
+
+  DartEntry visitIncrementalAnalysisTask(IncrementalAnalysisTask task) => AnalysisContextImpl_this.recordIncrementalAnalysisTaskResults(task);
 
   DartEntry visitParseDartTask(ParseDartTask task) => AnalysisContextImpl_this.recordParseDartTaskResults(task);
 
   HtmlEntry visitParseHtmlTask(ParseHtmlTask task) => AnalysisContextImpl_this.recordParseHtmlTaskResults(task);
 
   HtmlEntry visitResolveAngularComponentTemplateTask(ResolveAngularComponentTemplateTask task) => AnalysisContextImpl_this.recordResolveAngularComponentTemplateTaskResults(task);
 
-  SourceEntry visitResolveAngularEntryHtmlTask(ResolveAngularEntryHtmlTask task) => AnalysisContextImpl_this.recordResolveAngularEntryHtmlTaskResults(task);
+  HtmlEntry 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);
+  DartEntry visitResolveDartUnitTask(ResolveDartUnitTask task) => AnalysisContextImpl_this.recordResolveDartUnitTaskResults(task);
 
-  SourceEntry visitResolveHtmlTask(ResolveHtmlTask task) => AnalysisContextImpl_this.recordResolveHtmlTaskResults(task);
+  HtmlEntry visitResolveHtmlTask(ResolveHtmlTask task) => AnalysisContextImpl_this.recordResolveHtmlTaskResults(task);
 
-  SourceEntry visitScanDartTask(ScanDartTask task) => AnalysisContextImpl_this.recordScanDartTaskResults(task);
+  DartEntry 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) {
         return RetentionPriority.HIGH;
       }
     }
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       if (astIsNeeded(dartEntry)) {
         return RetentionPriority.MEDIUM;
       }
     }
     return RetentionPriority.LOW;
   }
 
   bool astIsNeeded(DartEntry dartEntry) => dartEntry.hasInvalidData(DartEntry.HINTS) || dartEntry.hasInvalidData(DartEntry.VERIFICATION_ERRORS) || dartEntry.hasInvalidData(DartEntry.RESOLUTION_ERRORS);
 }
 
 /**
+ * Instances of the class `TaskData` represent information about the next task to be
+ * performed. Each data has an implicit associated source: the source that might need to be
+ * analyzed. There are essentially three states that can be represented:
+ * * If [getTask] returns a non-`null` value, then that is the task that should
+ * be executed to further analyze the associated source.
+ * * Otherwise, if [isBlocked] returns `true`, then there is no work that can be
+ * done, but analysis for the associated source is not complete.
+ * * Otherwise, [getDependentSource] should return a source that needs to be analyzed
+ * before the analysis of the associated source can be completed.
+ */
+class AnalysisContextImpl_TaskData {
+  /**
+   * The task that is to be performed.
+   */
+  final AnalysisTask task;
+
+  /**
+   * A flag indicating whether the associated source is blocked waiting for its contents to be
+   * loaded.
+   */
+  bool _blocked = false;
+
+  /**
+   * The source that needs to be analyzed before further progress can be made on the associated
+   * source.
+   */
+  final Source dependentSource;
+
+  /**
+   * Initialize a newly created data holder.
+   *
+   * @param task the task that is to be performed
+   * @param blocked `true` if the associated source is blocked waiting for its contents to
+   *          be loaded
+   * @param dependentSource t
+   */
+  AnalysisContextImpl_TaskData(this.task, bool blocked, this.dependentSource) {
+    this._blocked = blocked;
+  }
+
+  /**
+   * Return `true` if the associated source is blocked waiting for its contents to be
+   * loaded.
+   *
+   * @return `true` if the associated source is blocked waiting for its contents to be
+   *         loaded
+   */
+  bool get isBlocked => _blocked;
+}
+
+/**
  * Instances of the class `AnalysisErrorInfoImpl` represent the analysis errors and line info
  * associated with a source.
  */
 class AnalysisErrorInfoImpl implements AnalysisErrorInfo {
   /**
    * The analysis errors associated with a source, or `null` if there are no errors.
    */
   final List<AnalysisError> errors;
 
   /**
@@ skipping 1893 matching lines @@
     StringToken token = createStringToken(name, offset);
     return new SimpleIdentifier(token);
   }
 
   /**
    * Adds [AngularElement] declared by the given top-level [Element].
    *
    * @param angularElements the list to fill with top-level [AngularElement]s
    * @param classElement the [ClassElement] to get [AngularElement]s from
    */
-  static void addAngularElements(Set<AngularElement> angularElements, ClassElement classElement) {
+  static void addAngularElementsFromClass(Set<AngularElement> angularElements, ClassElement classElement) {
     for (ToolkitObjectElement toolkitObject in classElement.toolkitObjects) {
       if (toolkitObject is AngularElement) {
         angularElements.add(toolkitObject);
       }
     }
   }
 
   /**
    * 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) {
+  static void addAngularElementsFromLibrary(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);
+        addAngularElementsFromClass(angularElements, type);
       }
     }
     // handle imports
     for (ImportElement importElement in library.imports) {
       LibraryElement importedLibrary = importElement.importedLibrary;
-      addAngularElements2(angularElements, importedLibrary, visited);
+      addAngularElementsFromLibrary(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> getAngularElements(Set<LibraryElement> libraries, LibraryElement libraryElement) {
     Set<AngularElement> angularElements = new Set();
-    addAngularElements2(angularElements, libraryElement, libraries);
+    addAngularElementsFromLibrary(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;
@@ skipping 130 matching lines @@
   }
 
   /**
    * Resolves [source] as an Angular application entry point.
    */
   void resolveEntryPoint(AngularApplication application) {
     resolveInternal(application.elements, null);
   }
 
   Object visitXmlAttributeNode(ht.XmlAttributeNode node) {
-    parseEmbeddedExpressions2(node);
+    parseEmbeddedExpressionsInAttribute(node);
     resolveExpressions(node.expressions);
     return super.visitXmlAttributeNode(node);
   }
 
   Object visitXmlTagNode(ht.XmlTagNode node) {
     bool wasAngular = _isAngular;
     try {
       // new Angular context
       if (node.getAttribute(_NG_APP) != null) {
         _isAngular = true;
         visitModelDirectives(node);
       }
       // not Angular
       if (!_isAngular) {
         return super.visitXmlTagNode(node);
       }
       // process node in separate name scope
       pushNameScope();
       try {
-        parseEmbeddedExpressions3(node);
+        parseEmbeddedExpressions2(node);
         // apply processors
         for (NgProcessor processor in _processors) {
           if (processor.canApply(node)) {
             processor.apply(this, node);
           }
         }
         // resolve expressions
         resolveExpressions(node.expressions);
         // process children
         return super.visitXmlTagNode(node);
@@ skipping 89 matching lines @@
       SimpleIdentifier name = parseDartExpression3(filterToken) as SimpleIdentifier;
       filterToken = name.endToken.next;
       // parse arguments
       List<AngularFilterArgument> arguments = [];
       while (filterToken.type != TokenType.EOF) {
         // skip ":"
         Token colonToken = filterToken;
         if (identical(colonToken.type, TokenType.COLON)) {
           filterToken = filterToken.next;
         } else {
-          reportError8(colonToken, AngularCode.MISSING_FILTER_COLON, []);
+          reportErrorForToken(AngularCode.MISSING_FILTER_COLON, colonToken, []);
         }
         // parse argument
         Expression argument = parseDartExpression3(filterToken);
         arguments.add(new AngularFilterArgument(colonToken, argument));
         // next token
         filterToken = argument.endToken.next;
       }
       filters.add(new AngularFilterNode(barToken, name, arguments));
     }
     // done
@@ skipping 19 matching lines @@
     _nameScope = _resolver.popNameScope();
   }
 
   void pushNameScope() {
     _nameScope = _resolver.pushNameScope();
   }
 
   /**
    * Reports given [ErrorCode] at the given [AstNode].
    */
-  void reportError(AstNode node, ErrorCode errorCode, List<Object> arguments) {
-    reportError7(node.offset, node.length, errorCode, arguments);
+  void reportErrorForNode(ErrorCode errorCode, AstNode node, List<Object> arguments) {
+    reportErrorForOffset(errorCode, node.offset, node.length, arguments);
   }
 
   /**
    * Reports given [ErrorCode] at the given position.
    */
-  void reportError7(int offset, int length, ErrorCode errorCode, List<Object> arguments) {
+  void reportErrorForOffset(ErrorCode errorCode, int offset, int length, List<Object> arguments) {
     _errorListener.onError(new AnalysisError.con2(_source, offset, length, errorCode, arguments));
   }
 
   /**
    * Reports given [ErrorCode] at the given [Token].
    */
-  void reportError8(Token token, ErrorCode errorCode, List<Object> arguments) {
-    reportError7(token.offset, token.length, errorCode, arguments);
+  void reportErrorForToken(ErrorCode errorCode, Token token, List<Object> arguments) {
+    reportErrorForOffset(errorCode, token.offset, token.length, arguments);
   }
 
   void resolveExpression(AngularExpression angularExpression) {
     List<Expression> dartExpressions = angularExpression.expressions;
     for (Expression dartExpression in dartExpressions) {
       resolveNode(dartExpression);
     }
   }
 
   /**
@@ skipping 103 matching lines @@
         return;
       } else if (startIndex + AngularMoustacheXmlExpression.OPENING_DELIMITER_LENGTH < endIndex) {
         startIndex += AngularMoustacheXmlExpression.OPENING_DELIMITER_LENGTH;
         AngularExpression expression = parseAngularExpression2(lexeme, startIndex, endIndex, offset);
         expressions.add(new AngularMoustacheXmlExpression(startIndex, endIndex, expression));
       }
       startIndex = StringUtilities.indexOf2(lexeme, endIndex + AngularMoustacheXmlExpression.CLOSING_DELIMITER_LENGTH, AngularMoustacheXmlExpression.OPENING_DELIMITER_CHAR, AngularMoustacheXmlExpression.OPENING_DELIMITER_CHAR);
     }
   }
 
-  void parseEmbeddedExpressions2(ht.XmlAttributeNode node) {
-    List<AngularMoustacheXmlExpression> expressions = [];
-    parseEmbeddedExpressions(expressions, node.valueToken);
-    if (!expressions.isEmpty) {
-      node.expressions = new List.from(expressions);
-    }
-  }
-
-  void parseEmbeddedExpressions3(ht.XmlTagNode node) {
+  void parseEmbeddedExpressions2(ht.XmlTagNode node) {
     List<AngularMoustacheXmlExpression> expressions = [];
     ht.Token token = node.attributeEnd;
     ht.Token endToken = node.endToken;
     bool inChild = false;
     while (token != endToken) {
       for (ht.XmlTagNode child in node.tagNodes) {
         if (identical(token, child.beginToken)) {
           inChild = true;
           break;
         }
         if (identical(token, child.endToken)) {
           inChild = false;
           break;
         }
       }
       if (!inChild && identical(token.type, ht.TokenType.TEXT)) {
         parseEmbeddedExpressions(expressions, token);
       }
       token = token.next;
     }
     node.expressions = new List.from(expressions);
   }
 
+  void parseEmbeddedExpressionsInAttribute(ht.XmlAttributeNode node) {
+    List<AngularMoustacheXmlExpression> expressions = [];
+    parseEmbeddedExpressions(expressions, node.valueToken);
+    if (!expressions.isEmpty) {
+      node.expressions = new List.from(expressions);
+    }
+  }
+
   void recordDefinedVariable(LocalVariableElementImpl variable) {
     _definedVariables.add(variable);
     _functionElement.localVariables = new List.from(_definedVariables);
   }
 
   /**
    * When we inject variable, we give access to the library of its type.
    */
   void recordTypeLibraryInjected(LocalVariableElementImpl variable) {
     LibraryElement typeLibrary = variable.type.element.library;
@@ skipping 199 matching lines @@
 abstract class AngularXmlExpression extends ht.XmlExpression {
   /**
    * The expression that is enclosed between the delimiters.
    */
   final AngularExpression expression;
 
   AngularXmlExpression(this.expression);
 
   ht.XmlExpression_Reference getReference(int offset) {
     // main expression
-    ht.XmlExpression_Reference reference = getReference2(expression.expression, offset);
+    ht.XmlExpression_Reference reference = getReferenceAtNode(expression.expression, offset);
     if (reference != null) {
       return reference;
     }
     // filters
     for (AngularFilterNode filter in expression.filters) {
       // filter name
-      reference = getReference2(filter.name, offset);
+      reference = getReferenceAtNode(filter.name, offset);
       if (reference != null) {
         return reference;
       }
       // filter arguments
       for (AngularFilterArgument filterArgument in filter.arguments) {
-        reference = getReference2(filterArgument.expression, offset);
+        reference = getReferenceAtNode(filterArgument.expression, offset);
         if (reference != null) {
           return reference;
         }
       }
     }
     return null;
   }
 
   /**
    * If the given [AstNode] has an [Element] at the given offset, then returns
    * [Reference] with this [Element].
    */
-  ht.XmlExpression_Reference getReference2(AstNode root, int offset) {
+  ht.XmlExpression_Reference getReferenceAtNode(AstNode root, int offset) {
     AstNode node = new NodeLocator.con1(offset).searchWithin(root);
     if (node != null) {
       Element element = ElementLocator.locate(node);
       return new ht.XmlExpression_Reference(element, node.offset, node.length);
     }
     return null;
   }
 }
 
 /**
@@ skipping 378 matching lines @@
   /**
    * Visit a [GenerateDartHintsTask].
    *
    * @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 visitGenerateDartHintsTask(GenerateDartHintsTask task);
 
   /**
+   * Visit a [GetContentTask].
+   *
+   * @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 visitGetContentTask(GetContentTask task);
+
+  /**
    * Visit an [IncrementalAnalysisTask].
    *
    * @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 visitIncrementalAnalysisTask(IncrementalAnalysisTask incrementalAnalysisTask);
 
   /**
    * Visit a [ParseDartTask].
@@ skipping 249 matching lines @@
    * Return the resolved compilation unit associated with the given source.
    *
    * @param unitSource the source for the compilation unit whose resolved AST is to be returned
    * @return the resolved compilation unit associated with the given source
    * @throws AnalysisException if the resolved compilation unit could not be computed
    */
   TimestampedData<CompilationUnit> getCompilationUnit(Source unitSource) => context.internalResolveCompilationUnit(unitSource, libraryElement);
 }
 
 /**
+ * Instances of the class `GetContentTask` get the contents of a source.
+ */
+class GetContentTask extends AnalysisTask {
+  /**
+   * The source to be read.
+   */
+  final Source source;
+
+  /**
+   * A flag indicating whether this task is complete.
+   */
+  bool _complete = false;
+
+  /**
+   * The contents of the source.
+   */
+  String _content;
+
+  /**
+   * The time at which the contents of the source were last modified.
+   */
+  int _modificationTime = -1;
+
+  /**
+   * 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
+   */
+  GetContentTask(InternalAnalysisContext context, this.source) : super(context) {
+    if (source == null) {
+      throw new IllegalArgumentException("Cannot get contents of null source");
+    }
+  }
+
+  accept(AnalysisTaskVisitor visitor) => visitor.visitGetContentTask(this);
+
+  /**
+   * Return the contents of the source, or `null` if the task has not completed or if there
+   * was an exception while getting the contents.
+   *
+   * @return the contents of the source
+   */
+  String get content => _content;
+
+  /**
+   * Return the time at which the contents of the source that was parsed were last modified, or a
+   * negative value if the task has not yet been performed or if an exception occurred.
+   *
+   * @return the time at which the contents of the source that was parsed were last modified
+   */
+  int get modificationTime => _modificationTime;
+
+  /**
+   * Return `true` if this task is complete. Unlike most tasks, this task is allowed to be
+   * visited more than once in order to support asynchronous IO. If the task is not complete when it
+   * is visited synchronously as part of the [AnalysisTask#perform]
+   * method, it will be visited again, using the same visitor, when the IO operation has been
+   * performed.
+   *
+   * @return `true` if this task is complete
+   */
+  bool get isComplete => _complete;
+
+  String get taskDescription => "get contents of ${source.fullName}";
+
+  void internalPerform() {
+    _complete = true;
+    try {
+      TimestampedData<String> data = context.getContents(source);
+      _content = data.data;
+      _modificationTime = data.modificationTime;
+    } on JavaException catch (exception) {
+      throw new AnalysisException.con2("Could not get contents of ${source}", exception);
+    }
+  }
+}
+
+/**
  * Instances of the class `IncrementalAnalysisTask` incrementally update existing analysis.
  */
 class IncrementalAnalysisTask extends AnalysisTask {
   /**
    * The information used to perform incremental analysis.
    */
   final IncrementalAnalysisCache cache;
 
   /**
    * The compilation unit that was produced by incrementally updating the existing unit.
@@ skipping 95 matching lines @@
   CompilationUnit _unit;
 
   /**
    * The errors that were produced by scanning and parsing the source.
    */
   List<AnalysisError> _errors = AnalysisError.NO_ERRORS;
 
   /**
    * A flag indicating whether the source contains a 'part of' directive.
    */
-  bool _hasPartOfDirective2 = false;
+  bool _containsPartOfDirective = false;
 
   /**
    * A flag indicating whether the source contains a 'library' directive.
    */
-  bool _hasLibraryDirective2 = false;
+  bool _containsLibraryDirective = false;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be parsed
    */
   ParseDartTask(InternalAnalysisContext context, this.source) : super(context);
 
   accept(AnalysisTaskVisitor visitor) => visitor.visitParseDartTask(this);
@@ skipping 21 matching lines @@
    * @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.
    *
    * @return `true` if the source contains a 'library' directive
    */
-  bool hasLibraryDirective() => _hasLibraryDirective2;
+  bool hasLibraryDirective() => _containsLibraryDirective;
 
   /**
    * Return `true` if the source contains a 'part of' directive, or `false` if the task
    * has not yet been performed or if an exception occurred.
    *
    * @return `true` if the source contains a 'part of' directive
    */
-  bool hasPartOfDirective() => _hasPartOfDirective2;
+  bool hasPartOfDirective() => _containsPartOfDirective;
 
   String get taskDescription {
     if (source == null) {
       return "parse as dart null source";
     }
     return "parse as dart ${source.fullName}";
   }
 
   void internalPerform() {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     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);
       _errors = errorListener.getErrors2(source);
       for (Directive directive in _unit.directives) {
         if (directive is LibraryDirective) {
-          _hasLibraryDirective2 = true;
+          _containsLibraryDirective = true;
         } else if (directive is PartOfDirective) {
-          _hasPartOfDirective2 = true;
+          _containsPartOfDirective = true;
         }
       }
       _unit.lineInfo = context.getLineInfo(source);
     } finally {
       timeCounterParse.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;
 
   /**
+   * The contents of the source.
+   */
+  String _content;
+
+  /**
    * The time at which the contents of the source were last modified.
    */
-  int _modificationTime = -1;
+  int _modificationTime = 0;
 
   /**
    * The line information that was produced.
    */
   LineInfo _lineInfo;
 
   /**
    * The HTML unit that was produced by parsing the source.
    */
   ht.HtmlUnit _unit;
@@ skipping 16 matching lines @@
   /**
    * The name of the 'script' tag in an HTML file.
    */
   static String _TAG_SCRIPT = "script";
 
   /**
    * 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
    */
-  ParseHtmlTask(InternalAnalysisContext context, this.source) : super(context);
+  ParseHtmlTask(InternalAnalysisContext context, this.source, TimestampedData<String> contentData) : super(context) {
+    _content = contentData.data;
+    _modificationTime = contentData.modificationTime;
+  }
 
   accept(AnalysisTaskVisitor visitor) => visitor.visitParseHtmlTask(this);
 
   /**
    * 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;
@@ skipping 30 matching lines @@
 
   String get taskDescription {
     if (source == null) {
       return "parse as html null source";
     }
     return "parse as html ${source.fullName}";
   }
 
   void internalPerform() {
     try {
-      TimestampedData<String> contents = context.getContents(source);
-      _modificationTime = contents.modificationTime;
-      ht.AbstractScanner scanner = new ht.StringScanner(source, contents.data);
+      ht.AbstractScanner scanner = new ht.StringScanner(source, _content);
       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);
     }
@@ skipping 757 matching lines @@
       _errors = errorListener.getErrors2(source);
     } on JavaException catch (exception) {
       throw new AnalysisException.con3(exception);
     } finally {
       timeCounterScan.stop();
     }
   }
 }
 
 /**
+ * The unique instances of the class `WaitForAsyncTask` represents a state in which there is
+ * no analysis work that can be done until some asynchronous task (such as IO) has completed, but
+ * where analysis is not yet complete.
+ */
+class WaitForAsyncTask extends AnalysisTask {
+  /**
+   * The unique instance of this class.
+   */
+  static WaitForAsyncTask _UniqueInstance = new WaitForAsyncTask();
+
+  /**
+   * Return the unique instance of this class.
+   *
+   * @return the unique instance of this class
+   */
+  static WaitForAsyncTask get instance => _UniqueInstance;
+
+  /**
+   * Prevent the creation of instances of this class.
+   */
+  WaitForAsyncTask() : super(null);
+
+  accept(AnalysisTaskVisitor visitor) => null;
+
+  String get taskDescription => "Waiting for async analysis";
+
+  void internalPerform() {
+  }
+}
+
+/**
  * 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.
  */
 abstract class Logger {
   static final Logger NULL = new Logger_NullLogger();
 
   /**
    * Log the given message as an error.
@@ skipping 36 matching lines @@
 
   void logError2(String message, Exception exception) {
   }
 
   void logInformation(String message) {
   }
 
   void logInformation3(String message, Exception exception) {
   }
 }