Analyzer snapshot with disabled 'this.field' generation.

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 194 matching lines @@
    * @param changeSet a description of the changes that are to be applied
    */
   void applyChanges(ChangeSet changeSet);
 
   /**
    * Return the documentation comment for the given element as it appears in the original source
    * (complete with the beginning and ending delimiters), or `null` if the element does not
    * have a documentation comment associated with it. This can be a long-running operation if the
    * information needed to access the comment is not cached.
    *
+   * <b>Note:</b> This method cannot be used in an async environment.
+   *
    * @param element the element whose documentation comment is to be returned
    * @return the element's documentation comment
    * @throws AnalysisException if the documentation comment could not be determined because the
    *           analysis could not be performed
    */
   String computeDocumentationComment(Element element);
 
   /**
    * Return an array containing all of the errors associated with the given source. If the errors
    * are not already known then the source will be analyzed in order to determine the errors
    * associated with it.
    *
-   * <b>Note:</b> This method cannot be used in an async environment
+   * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source whose errors are to be returned
    * @return all of the errors associated with the given source
    * @throws AnalysisException if the errors could not be determined because the analysis could not
    *           be performed
    * @see #getErrors(Source)
    */
   List<AnalysisError> computeErrors(Source source);
 
   /**
    * Return the element model corresponding to the HTML file defined by the given source. If the
    * element model does not yet exist it will be created. The process of creating an element model
    * for an HTML file can long-running, depending on the size of the file and the number of
    * libraries that are defined in it (via script tags) that also need to have a model built for
    * them.
    *
-   * <b>Note:</b> This method cannot be used in an async environment
+   * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source defining the HTML file whose element model is to be returned
    * @return the element model corresponding to the HTML file defined by the given source
    * @throws AnalysisException if the element model could not be determined because the analysis
    *           could not be performed
    * @see #getHtmlElement(Source)
    */
   HtmlElement computeHtmlElement(Source source);
 
   /**
    * Return the kind of the given source, computing it's kind if it is not already known. Return
    * [SourceKind#UNKNOWN] if the source is not contained in this context.
    *
-   * <b>Note:</b> This method cannot be used in an async environment
+   * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source whose kind is to be returned
    * @return the kind of the given source
    * @see #getKindOf(Source)
    */
   SourceKind computeKindOf(Source source);
 
   /**
    * Return the element model corresponding to the library defined by the given source. If the
    * element model does not yet exist it will be created. The process of creating an element model
    * for a library can long-running, depending on the size of the library and the number of
    * libraries that are imported into it that also need to have a model built for them.
    *
+   * <b>Note:</b> This method cannot be used in an async environment.
+   *
    * @param source the source defining the library whose element model is to be returned
    * @return the element model corresponding to the library defined by the given source
    * @throws AnalysisException if the element model could not be determined because the analysis
    *           could not be performed
    * @see #getLibraryElement(Source)
    */
   LibraryElement computeLibraryElement(Source source);
 
   /**
    * Return the line information for the given source, or `null` if the source is not of a
    * recognized kind (neither a Dart nor HTML file). If the line information was not previously
    * known it will be created. The line information is used to map offsets from the beginning of the
    * source to line and column pairs.
    *
-   * <b>Note:</b> This method cannot be used in an async environment
+   * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @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);
 
   /**
@@ skipping 299 matching lines @@
    * sources should be reanalyzed as part of this context.
    *
    * @param context the context being merged
    */
   void mergeContext(AnalysisContext context);
 
   /**
    * Parse a single source to produce an AST structure. The resulting AST structure may or may not
    * be resolved, and may have a slightly different structure depending upon whether it is resolved.
    *
-   * <b>Note:</b> This method cannot be used in an async environment
+   * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the source to be parsed
    * @return the AST structure representing the content of the source
    * @throws AnalysisException if the analysis could not be performed
    */
   CompilationUnit parseCompilationUnit(Source source);
 
   /**
    * Parse a single HTML source to produce an AST structure. The resulting HTML AST structure may or
    * may not be resolved, and may have a slightly different structure depending upon whether it is
    * resolved.
    *
-   * <b>Note:</b> This method cannot be used in an async environment
+   * <b>Note:</b> This method cannot be used in an async environment.
    *
    * @param source the HTML source to be parsed
    * @return the parse result (not `null`)
    * @throws AnalysisException if the analysis could not be performed
    */
   ht.HtmlUnit parseHtmlUnit(Source source);
 
   /**
    * Perform the next unit of work required to keep the analysis results up-to-date and return
    * information about the consequent changes to the analysis results. This method can be long
@@ skipping 218 matching lines @@
 class AnalysisResult {
   /**
    * The change notices associated with this result, or `null` if there were no changes and
    * there is no more work to be done.
    */
   List<ChangeNotice> _notices;
 
   /**
    * The number of milliseconds required to determine which task was to be performed.
    */
-  final int getTime;
+  int getTime = 0;
 
   /**
    * The name of the class of the task that was performed.
    */
-  final String taskClassName;
+  String taskClassName;
 
   /**
    * The number of milliseconds required to perform the task.
    */
-  final int performTime;
+  int performTime = 0;
 
   /**
    * Initialize a newly created analysis result to have the given values.
    *
    * @param notices the change notices associated with this result
    * @param getTime the number of milliseconds required to determine which task was to be performed
    * @param taskClassName the name of the class of the task that was performed
    * @param performTime the number of milliseconds required to perform the task
    */
-  AnalysisResult(List<ChangeNotice> notices, this.getTime, this.taskClassName, this.performTime) {
+  AnalysisResult(List<ChangeNotice> notices, int getTime, String taskClassName, int performTime) {
     this._notices = notices;
+    this.getTime = getTime;
+    this.taskClassName = taskClassName;
+    this.performTime = performTime;
   }
 
   /**
    * Return the change notices associated with this result, or `null` if there were no changes
    * and there is no more work to be done.
    *
    * @return the change notices associated with this result
    */
   List<ChangeNotice> get changeNotices => _notices;
 
@@ skipping 480 matching lines @@
    * 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 errors reported during the resolution of directives.
-   */
-  static final DataDescriptor<List<AnalysisError>> DIRECTIVE_ERRORS = new DataDescriptor<List<AnalysisError>>("DartEntry.DIRECTIVE_ERRORS");
-
-  /**
    * The data descriptor representing the library element for the library. This data is only
    * available for Dart files that are the defining compilation unit of a library.
    */
   static final DataDescriptor<LibraryElement> ELEMENT = new DataDescriptor<LibraryElement>("DartEntry.ELEMENT");
 
   /**
    * The data descriptor representing the list of exported libraries. This data is only available
    * for Dart files that are the defining compilation unit of a library.
    */
   static final DataDescriptor<List<Source>> EXPORTED_LIBRARIES = new DataDescriptor<List<Source>>("DartEntry.EXPORTED_LIBRARIES");
@@ skipping 126 matching lines @@
    * Return `true` if the data represented by the given descriptor is marked as being invalid.
    * If the descriptor represents library-specific data then this method will return `true` if
    * the data associated with any library it marked as invalid.
    *
    * @param descriptor the descriptor representing which data is being tested
    * @return `true` if the data is marked as being invalid
    */
   bool hasInvalidData(DataDescriptor descriptor);
 
   /**
+   * Return `true` if this entry has an AST structure that can be resolved (even if it needs
+   * to be copied).
+   *
+   * @return `true` if the method [DartEntryImpl#getResolvableCompilationUnit] will
+   *         return a non-`null` result
+   */
+  bool get hasResolvableCompilationUnit;
+
+  /**
    * Return `true` if this data is safe to use in refactoring.
    */
   bool get isRefactoringSafe;
 }
 
 /**
  * Instances of the class `DartEntryImpl` implement a [DartEntry].
  */
 class DartEntryImpl extends SourceEntryImpl implements DartEntry {
   /**
@@ skipping 82 matching lines @@
    */
   CacheState _includedPartsState = CacheState.INVALID;
 
   /**
    * The list of parts included in the library, or an empty array if the list is not currently
    * cached. The list will be empty if the Dart file is a part rather than a library.
    */
   List<Source> _includedParts = Source.EMPTY_ARRAY;
 
   /**
-   * The state of the cached directive errors.
-   */
-  CacheState _directiveErrorsState = CacheState.INVALID;
-
-  /**
-   * The errors produced while resolving the directives, or an empty array if the errors are not
-   * currently cached.
-   */
-  List<AnalysisError> _directiveErrors = AnalysisError.NO_ERRORS;
-
-  /**
    * The list of libraries that contain this compilation unit. The list will be empty if there are
    * no known libraries that contain this compilation unit.
    */
   List<Source> _containingLibraries = new List<Source>();
 
   /**
    * The information known as a result of resolving this compilation unit as part of the library
    * that contains this unit. This field will never be `null`.
    */
   DartEntryImpl_ResolutionState _resolutionState = new DartEntryImpl_ResolutionState();
@@ skipping 76 matching lines @@
       _parsedUnit = null;
     }
     _resolutionState.flushAstStructures();
   }
 
   @override
   List<AnalysisError> get allErrors {
     List<AnalysisError> errors = new List<AnalysisError>();
     ListUtilities.addAll(errors, _scanErrors);
     ListUtilities.addAll(errors, _parseErrors);
-    ListUtilities.addAll(errors, _directiveErrors);
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
       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;
@@ skipping 64 matching lines @@
         return state._resolvedUnit.accept(new AstCloner()) as CompilationUnit;
       }
       state = state._nextState;
     }
     ;
     return null;
   }
 
   @override
   CacheState getState(DataDescriptor descriptor) {
-    if (identical(descriptor, DartEntry.DIRECTIVE_ERRORS)) {
-      return _directiveErrorsState;
-    } else if (identical(descriptor, DartEntry.ELEMENT)) {
+    if (identical(descriptor, DartEntry.ELEMENT)) {
       return _elementState;
     } else if (identical(descriptor, DartEntry.EXPORTED_LIBRARIES)) {
       return _exportedLibrariesState;
     } else if (identical(descriptor, DartEntry.IMPORTED_LIBRARIES)) {
       return _importedLibrariesState;
     } else if (identical(descriptor, DartEntry.INCLUDED_PARTS)) {
       return _includedPartsState;
     } else if (identical(descriptor, DartEntry.IS_CLIENT)) {
       return _clientServerState;
     } else if (identical(descriptor, DartEntry.IS_LAUNCHABLE)) {
@@ skipping 41 matching lines @@
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
 
   @override
   Object getValue(DataDescriptor descriptor) {
     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.DIRECTIVE_ERRORS)) {
-      return _directiveErrors;
     } 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.get(_bitmask, _CLIENT_CODE_INDEX);
@@ skipping 47 matching lines @@
 
   @override
   DartEntryImpl get writableCopy {
     DartEntryImpl copy = new DartEntryImpl();
     copy.copyFrom(this);
     return copy;
   }
 
   @override
   bool hasInvalidData(DataDescriptor descriptor) {
-    if (identical(descriptor, DartEntry.DIRECTIVE_ERRORS)) {
-      return identical(_directiveErrorsState, CacheState.INVALID);
-    } else if (identical(descriptor, DartEntry.ELEMENT)) {
+    if (identical(descriptor, DartEntry.ELEMENT)) {
       return identical(_elementState, CacheState.INVALID);
     } else if (identical(descriptor, DartEntry.EXPORTED_LIBRARIES)) {
       return identical(_exportedLibrariesState, CacheState.INVALID);
     } else if (identical(descriptor, DartEntry.IMPORTED_LIBRARIES)) {
       return identical(_importedLibrariesState, CacheState.INVALID);
     } else if (identical(descriptor, DartEntry.INCLUDED_PARTS)) {
       return identical(_includedPartsState, CacheState.INVALID);
     } else if (identical(descriptor, DartEntry.IS_CLIENT)) {
       return identical(_clientServerState, CacheState.INVALID);
     } else if (identical(descriptor, DartEntry.IS_LAUNCHABLE)) {
@@ skipping 23 matching lines @@
           return identical(state._hintsState, CacheState.INVALID);
         }
       }
       return false;
     } else {
       return identical(super.getState(descriptor), CacheState.INVALID);
     }
   }
 
   @override
+  bool get hasResolvableCompilationUnit {
+    if (identical(_parsedUnitState, CacheState.VALID)) {
+      return true;
+    }
+    DartEntryImpl_ResolutionState state = _resolutionState;
+    while (state != null) {
+      if (identical(state._resolvedUnitState, CacheState.VALID)) {
+        return true;
+      }
+      state = state._nextState;
+    }
+    ;
+    return false;
+  }
+
+  @override
   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;
+    _importedLibraries = Source.EMPTY_ARRAY;
+    _importedLibrariesState = CacheState.INVALID;
+    _exportedLibraries = Source.EMPTY_ARRAY;
+    _exportedLibrariesState = CacheState.INVALID;
+    _includedParts = Source.EMPTY_ARRAY;
+    _includedPartsState = CacheState.INVALID;
     _discardCachedResolutionInformation();
   }
 
   /**
    * Invalidate all of the resolution information associated with the compilation unit.
    */
   void invalidateAllResolutionInformation() {
     if (identical(_parsedUnitState, CacheState.FLUSHED)) {
       DartEntryImpl_ResolutionState state = _resolutionState;
       while (state != null) {
@@ skipping 22 matching lines @@
     return true;
   }
 
   @override
   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;
-    _includedPartsState = CacheState.ERROR;
-    _directiveErrors = AnalysisError.NO_ERRORS;
-    _directiveErrorsState = CacheState.ERROR;
-  }
-
-  /**
-   * Record that the information related to resolving dependencies for the associated source is
-   * about to be computed by the current thread.
-   */
-  void recordDependencyInProcess() {
-    if (_exportedLibrariesState != CacheState.VALID) {
-      _exportedLibrariesState = CacheState.IN_PROCESS;
-    }
-    if (_importedLibrariesState != CacheState.VALID) {
-      _importedLibrariesState = CacheState.IN_PROCESS;
-    }
-    if (_includedPartsState != CacheState.VALID) {
-      _includedPartsState = CacheState.IN_PROCESS;
-    }
-    if (_directiveErrorsState != CacheState.VALID) {
-      _directiveErrorsState = CacheState.IN_PROCESS;
-    }
-  }
-
-  /**
-   * Record that an in-process dependency resolution has stopped without recording results because
-   * the results were invalidated before they could be recorded.
-   */
-  void recordDependencyNotInProcess() {
-    if (identical(_exportedLibrariesState, CacheState.IN_PROCESS)) {
-      _exportedLibrariesState = CacheState.INVALID;
-    }
-    if (identical(_importedLibrariesState, CacheState.IN_PROCESS)) {
-      _importedLibrariesState = CacheState.INVALID;
-    }
-    if (identical(_includedPartsState, CacheState.IN_PROCESS)) {
-      _includedPartsState = CacheState.INVALID;
-    }
-    if (identical(_directiveErrorsState, CacheState.IN_PROCESS)) {
-      _directiveErrorsState = 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() {
     _sourceKind = SourceKind.UNKNOWN;
     _sourceKindState = CacheState.ERROR;
     _parseErrors = AnalysisError.NO_ERRORS;
     _parseErrorsState = CacheState.ERROR;
     _parsedUnit = null;
     _parsedUnitAccessed = false;
     _parsedUnitState = CacheState.ERROR;
-    recordDependencyError();
+    _exportedLibraries = Source.EMPTY_ARRAY;
+    _exportedLibrariesState = CacheState.ERROR;
+    _importedLibraries = Source.EMPTY_ARRAY;
+    _importedLibrariesState = CacheState.ERROR;
+    _includedParts = Source.EMPTY_ARRAY;
+    _includedPartsState = CacheState.ERROR;
     recordResolutionError();
   }
 
   /**
    * Record that the parse-related information for the associated source is about to be computed by
    * the current thread.
    */
   void recordParseInProcess() {
     if (_sourceKindState != CacheState.VALID) {
       _sourceKindState = CacheState.IN_PROCESS;
     }
     if (_parseErrorsState != CacheState.VALID) {
       _parseErrorsState = CacheState.IN_PROCESS;
     }
     if (_parsedUnitState != CacheState.VALID) {
       _parsedUnitState = CacheState.IN_PROCESS;
     }
+    if (_exportedLibrariesState != CacheState.VALID) {
+      _exportedLibrariesState = CacheState.IN_PROCESS;
+    }
+    if (_importedLibrariesState != CacheState.VALID) {
+      _importedLibrariesState = CacheState.IN_PROCESS;
+    }
+    if (_includedPartsState != CacheState.VALID) {
+      _includedPartsState = CacheState.IN_PROCESS;
+    }
   }
 
   /**
    * Record that an in-process parse has stopped without recording results because the results were
    * invalidated before they could be recorded.
    */
   void recordParseNotInProcess() {
     if (identical(getState(SourceEntry.LINE_INFO), CacheState.IN_PROCESS)) {
       setState(SourceEntry.LINE_INFO, CacheState.INVALID);
     }
     if (identical(_sourceKindState, CacheState.IN_PROCESS)) {
       _sourceKindState = CacheState.INVALID;
     }
     if (identical(_parseErrorsState, CacheState.IN_PROCESS)) {
       _parseErrorsState = CacheState.INVALID;
     }
     if (identical(_parsedUnitState, CacheState.IN_PROCESS)) {
       _parsedUnitState = CacheState.INVALID;
     }
+    if (identical(_exportedLibrariesState, CacheState.IN_PROCESS)) {
+      _exportedLibrariesState = CacheState.INVALID;
+    }
+    if (identical(_importedLibrariesState, CacheState.IN_PROCESS)) {
+      _importedLibrariesState = CacheState.INVALID;
+    }
+    if (identical(_includedPartsState, CacheState.IN_PROCESS)) {
+      _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 resolution-based information as being in error, but will
    * not change the state of any parse results.
    */
   void recordResolutionError() {
     _element = null;
     _elementState = CacheState.ERROR;
@@ skipping 117 matching lines @@
    *
    * @param librarySource the source of the single library that the list should contain
    */
   void set containingLibrary(Source librarySource) {
     _containingLibraries.clear();
     _containingLibraries.add(librarySource);
   }
 
   @override
   void setState(DataDescriptor descriptor, CacheState state) {
-    if (identical(descriptor, DartEntry.DIRECTIVE_ERRORS)) {
-      _directiveErrors = updatedValue(state, _directiveErrors, null);
-      _directiveErrorsState = state;
-    } else if (identical(descriptor, DartEntry.ELEMENT)) {
+    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;
     } else if (identical(descriptor, DartEntry.INCLUDED_PARTS)) {
       _includedParts = updatedValue(state, _includedParts, Source.EMPTY_ARRAY);
@@ skipping 56 matching lines @@
       state._hintsState = cacheState;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
 
   @override
   void setValue(DataDescriptor descriptor, Object value) {
     if (identical(descriptor, DartEntry.ANGULAR_ERRORS)) {
       _angularErrors = value == null ? AnalysisError.NO_ERRORS : (value as List<AnalysisError>);
-    } else if (identical(descriptor, DartEntry.DIRECTIVE_ERRORS)) {
-      _directiveErrors = value as List<AnalysisError>;
-      _directiveErrorsState = CacheState.VALID;
     } 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)) {
@@ skipping 69 matching lines @@
     _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;
-    _directiveErrorsState = other._directiveErrorsState;
-    _directiveErrors = other._directiveErrors;
     _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;
   }
 
   @override
-  bool get 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(_directiveErrorsState, CacheState.ERROR) || identical(_elementState, CacheState.ERROR) || identical(_publicNamespaceState, CacheState.ERROR) || identical(_clientServerState, CacheState.ERROR) || identical(_launchableState, CacheState.ERROR) || _resolutionState.hasErrorState;
+  bool get 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;
 
   @override
   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);
     builder.append("; importedLibraries = ");
     builder.append(_importedLibrariesState);
     builder.append("; includedParts = ");
     builder.append(_includedPartsState);
-    builder.append("; directiveErrors = ");
-    builder.append(_directiveErrorsState);
     builder.append("; element = ");
     builder.append(_elementState);
     builder.append("; publicNamespace = ");
     builder.append(_publicNamespaceState);
     builder.append("; clientServer = ");
     builder.append(_clientServerState);
     builder.append("; launchable = ");
     builder.append(_launchableState);
     //    builder.append("; angularElements = ");
     _resolutionState.writeOn(builder);
   }
 
   /**
    * Invalidate all of the resolution information associated with the compilation unit.
    */
   void _discardCachedResolutionInformation() {
     _element = null;
     _elementState = CacheState.INVALID;
-    _includedParts = Source.EMPTY_ARRAY;
-    _includedPartsState = CacheState.INVALID;
-    _exportedLibraries = Source.EMPTY_ARRAY;
-    _exportedLibrariesState = CacheState.INVALID;
-    _importedLibraries = Source.EMPTY_ARRAY;
-    _importedLibrariesState = CacheState.INVALID;
-    _directiveErrors = AnalysisError.NO_ERRORS;
-    _directiveErrorsState = CacheState.INVALID;
     _bitmask = 0;
     _clientServerState = CacheState.INVALID;
     _launchableState = CacheState.INVALID;
     _publicNamespace = null;
     _publicNamespaceState = CacheState.INVALID;
     _resolutionState.invalidateAllResolutionInformation();
   }
 
   /**
    * Return a resolution state for the specified library, creating one as necessary.
@@ skipping 1114 matching lines @@
     if (identical(state, CacheState.ERROR)) {
       AnalysisException exception = dartEntry.exception;
       if (exception != null) {
         _exceptions.add(exception);
       }
     }
   }
 }
 
 class AnalysisContentStatisticsImpl_CacheRowImpl implements AnalysisContentStatistics_CacheRow {
-  final String name;
+  String name;
 
   int _errorCount = 0;
 
   int _flushedCount = 0;
 
   int _inProcessCount = 0;
 
   int _invalidCount = 0;
 
   int _validCount = 0;
 
-  AnalysisContentStatisticsImpl_CacheRowImpl(this.name);
+  AnalysisContentStatisticsImpl_CacheRowImpl(String name) {
+    this.name = name;
+  }
 
   @override
   bool operator ==(Object obj) => obj is AnalysisContentStatisticsImpl_CacheRowImpl && obj.name == name;
 
   @override
   int get errorCount => _errorCount;
 
   @override
   int get flushedCount => _flushedCount;
 
@@ skipping 264 matching lines @@
       try {
         return _getHtmlResolutionData2(source, htmlEntry, HtmlEntry.RESOLUTION_ERRORS);
       } on ObsoleteSourceAnalysisException catch (exception) {
         AnalysisEngine.instance.logger.logInformation2("Could not compute errors", exception);
       }
     }
     return AnalysisError.NO_ERRORS;
   }
 
   @override
-  List<Source> computeExportedLibraries(Source source) => _getDartDependencyData2(source, DartEntry.EXPORTED_LIBRARIES, Source.EMPTY_ARRAY);
+  List<Source> computeExportedLibraries(Source source) => _getDartParseData2(source, DartEntry.EXPORTED_LIBRARIES, Source.EMPTY_ARRAY);
 
   @override
   HtmlElement computeHtmlElement(Source source) => _getHtmlResolutionData(source, HtmlEntry.ELEMENT, null);
 
   @override
-  List<Source> computeImportedLibraries(Source source) => _getDartDependencyData2(source, DartEntry.IMPORTED_LIBRARIES, Source.EMPTY_ARRAY);
+  List<Source> computeImportedLibraries(Source source) => _getDartParseData2(source, DartEntry.IMPORTED_LIBRARIES, Source.EMPTY_ARRAY);
 
   @override
   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) {
@@ skipping 27 matching lines @@
     if (dartEntry == null) {
       throw new AnalysisException.con1("computeResolvableCompilationUnit for non-Dart: ${source.fullName}");
     }
     dartEntry = _cacheDartParseData(source, dartEntry, DartEntry.PARSED_UNIT);
     DartEntryImpl dartCopy = dartEntry.writableCopy;
     CompilationUnit unit = dartCopy.resolvableCompilationUnit;
     if (unit == null) {
       throw new AnalysisException.con2("Internal error: computeResolvableCompilationUnit could not parse ${source.fullName}", dartEntry.exception);
     }
     _cache.put(source, dartCopy);
-    return new ResolvableCompilationUnit(dartCopy.modificationTime, unit);
+    return new ResolvableCompilationUnit.con1(dartCopy.modificationTime, unit);
   }
 
   @override
   void dispose() {
     _disposed = true;
   }
 
   @override
   bool exists(Source source) {
     if (source == null) {
@@ skipping 252 matching lines @@
       if (identical(dartEntry.getValue(DartEntry.ELEMENT), library)) {
         DartEntryImpl dartCopy = _getReadableDartEntry(source).writableCopy;
         dartCopy.setValue(DartEntry.PUBLIC_NAMESPACE, namespace);
         _cache.put(source, dartCopy);
       }
     }
     return namespace;
   }
 
   @override
-  Namespace getPublicNamespace2(Source source) {
-    // TODO(brianwilkerson) Rename this to not start with 'get'. Note that this is not part of the
-    // API of the interface.
-    DartEntry dartEntry = _getReadableDartEntry(source);
-    if (dartEntry == null) {
-      return null;
-    }
-    Namespace namespace = dartEntry.getValue(DartEntry.PUBLIC_NAMESPACE);
-    if (namespace == null) {
-      LibraryElement library = computeLibraryElement(source);
-      if (library == null) {
-        return null;
-      }
-      NamespaceBuilder builder = new NamespaceBuilder();
-      namespace = builder.createPublicNamespaceForLibrary(library);
-      dartEntry = _getReadableDartEntry(source);
-      if (dartEntry == null) {
-        throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
-      }
-      if (identical(dartEntry.getValue(DartEntry.ELEMENT), library)) {
-        DartEntryImpl dartCopy = _getReadableDartEntry(source).writableCopy;
-        dartCopy.setValue(DartEntry.PUBLIC_NAMESPACE, namespace);
-        _cache.put(source, dartCopy);
-      }
-    }
-    return namespace;
-  }
-
-  @override
   List<Source> get refactoringUnsafeSources {
     List<Source> sources = new List<Source>();
     for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
       SourceEntry sourceEntry = entry.getValue();
       if (sourceEntry is DartEntry) {
         if (!sourceEntry.isRefactoringSafe) {
           sources.add(entry.getKey());
         }
       }
     }
@@ skipping 528 matching lines @@
           // The source has changed without the context being notified. Simulate notification.
           _sourceChanged(source);
           allTimesMatch = false;
         }
       }
     }
     return allTimesMatch;
   }
 
   /**
-   * 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 resolving the directives in the source if they
-   * are not already cached.
-   *
-   * <b>Note:</b> This method cannot be used in an async environment
-   *
-   * @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
-   */
-  DartEntry _cacheDartDependencyData(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.
-      //
-      dartEntry = _cacheDartParseData(source, dartEntry, DartEntry.PARSED_UNIT);
-      CompilationUnit unit = dartEntry.anyParsedCompilationUnit;
-      if (unit == null) {
-        throw new AnalysisException.con2("Could not cache Dart dependency data: no parse unit", dartEntry.exception);
-      }
-      dartEntry = new ResolveDartDependenciesTask(this, source, dartEntry.modificationTime, unit).perform(_resultRecorder) as DartEntry;
-      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 generating hints
    * for the 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 38 matching lines @@
     //
     // 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.
       //
       dartEntry = _cacheDartScanData(source, dartEntry, DartEntry.TOKEN_STREAM);
-      dartEntry = new ParseDartTask(this, source, dartEntry.modificationTime, dartEntry.getValue(DartEntry.TOKEN_STREAM)).perform(_resultRecorder) as DartEntry;
+      dartEntry = new ParseDartTask(this, source, dartEntry.modificationTime, dartEntry.getValue(DartEntry.TOKEN_STREAM), dartEntry.getValue(SourceEntry.LINE_INFO)).perform(_resultRecorder) as DartEntry;
       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 resolving the
    * source in the context of the library if it is not already cached.
@@ skipping 61 matching lines @@
     }
     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.
    *
+   * <b>Note:</b> This method cannot be used in an async environment.
+   *
    * @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
    * @throws AnalysisException if data could not be returned because the source could not be parsed
    */
   DartEntry _cacheDartVerificationData(Source unitSource, Source librarySource, DartEntry dartEntry, DataDescriptor descriptor) {
     //
     // Check to see whether we already have the information being requested.
@@ skipping 132 matching lines @@
    * Create a [GetContentTask] for the given source, marking the content as being in-process.
    *
    * @param source the source whose content is to be accessed
    * @param sourceEntry the entry for the source
    * @return task data representing the created task
    */
   AnalysisContextImpl_TaskData _createGetContentTask(Source source, SourceEntry sourceEntry) {
     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);
+    return new AnalysisContextImpl_TaskData(new GetContentTask(this, source), false);
   }
 
   /**
    * Create a [ParseDartTask] for the given source, marking the parse errors as being
    * in-process.
    *
    * @param source the source whose content is to be parsed
    * @param dartEntry the entry for the source
    * @return task data representing the created task
    */
   AnalysisContextImpl_TaskData _createParseDartTask(Source source, DartEntry dartEntry) {
-    if (dartEntry.getState(DartEntry.TOKEN_STREAM) != CacheState.VALID) {
+    if (dartEntry.getState(DartEntry.TOKEN_STREAM) != CacheState.VALID || dartEntry.getState(SourceEntry.LINE_INFO) != CacheState.VALID) {
       return _createScanDartTask(source, dartEntry);
     }
     Token tokenStream = dartEntry.getValue(DartEntry.TOKEN_STREAM);
     DartEntryImpl dartCopy = dartEntry.writableCopy;
     dartCopy.setState(DartEntry.TOKEN_STREAM, CacheState.FLUSHED);
     dartCopy.setState(DartEntry.PARSE_ERRORS, CacheState.IN_PROCESS);
     _cache.put(source, dartCopy);
-    return new AnalysisContextImpl_TaskData(new ParseDartTask(this, source, dartCopy.modificationTime, tokenStream), false, null);
+    return new AnalysisContextImpl_TaskData(new ParseDartTask(this, source, dartCopy.modificationTime, tokenStream, dartEntry.getValue(SourceEntry.LINE_INFO)), false);
   }
 
   /**
    * Create a [ParseHtmlTask] for the given source, marking the parse errors as being
    * in-process.
    *
    * @param source the source whose content is to be parsed
    * @param htmlEntry the entry for the source
    * @return task data representing the created task
    */
   AnalysisContextImpl_TaskData _createParseHtmlTask(Source source, HtmlEntry htmlEntry) {
     if (htmlEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) {
       return _createGetContentTask(source, htmlEntry);
     }
     String content = htmlEntry.getValue(SourceEntry.CONTENT);
     HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
     htmlCopy.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
     htmlCopy.setState(HtmlEntry.PARSE_ERRORS, CacheState.IN_PROCESS);
     _cache.put(source, htmlCopy);
-    return new AnalysisContextImpl_TaskData(new ParseHtmlTask(this, source, htmlCopy.modificationTime, content), false, null);
+    return new AnalysisContextImpl_TaskData(new ParseHtmlTask(this, source, htmlCopy.modificationTime, content), false);
   }
 
   /**
-   * Create a [ResolveDartDependenciesTask] for the given source, marking the exported
-   * libraries as being in-process.
+   * Create a [ResolveAngularComponentTemplateTask] for the given source, marking the angular
+   * errors as being in-process.
    *
-   * @param source the source whose content is to be used to resolve dependencies
-   * @param dartEntry the entry for the source
+   * @param source the source whose content is to be resolved
+   * @param htmlEntry the entry for the source
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData _createResolveDartDependenciesTask(Source source, DartEntry dartEntry) {
-    CompilationUnit unit = dartEntry.anyParsedCompilationUnit;
-    if (unit == null) {
-      return _createParseDartTask(source, dartEntry);
+  AnalysisContextImpl_TaskData _createResolveAngularComponentTemplateTask(Source source, HtmlEntry htmlEntry) {
+    if (htmlEntry.getState(HtmlEntry.RESOLVED_UNIT) != CacheState.VALID) {
+      return _createResolveHtmlTask(source, htmlEntry);
     }
-    DartEntryImpl dartCopy = dartEntry.writableCopy;
-    dartCopy.setState(DartEntry.EXPORTED_LIBRARIES, CacheState.IN_PROCESS);
-    _cache.put(source, dartCopy);
-    return new AnalysisContextImpl_TaskData(new ResolveDartDependenciesTask(this, source, dartCopy.modificationTime, unit), false, null);
+    AngularApplication application = htmlEntry.getValue(HtmlEntry.ANGULAR_APPLICATION);
+    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 AnalysisContextImpl_TaskData(new ResolveAngularComponentTemplateTask(this, source, htmlCopy.modificationTime, htmlCopy.getValue(HtmlEntry.RESOLVED_UNIT), component, application), false);
   }
 
   /**
+   * Create a [ResolveAngularEntryHtmlTask] for the given source, marking the angular entry as
+   * being in-process.
+   *
+   * @param source the source whose content is to be resolved
+   * @param htmlEntry the entry for the source
+   * @return task data representing the created task
+   */
+  AnalysisContextImpl_TaskData _createResolveAngularEntryHtmlTask(Source source, HtmlEntry htmlEntry) {
+    if (htmlEntry.getState(HtmlEntry.RESOLVED_UNIT) != CacheState.VALID) {
+      return _createResolveHtmlTask(source, htmlEntry);
+    }
+    HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
+    htmlCopy.setState(HtmlEntry.ANGULAR_ENTRY, CacheState.IN_PROCESS);
+    _cache.put(source, htmlCopy);
+    return new AnalysisContextImpl_TaskData(new ResolveAngularEntryHtmlTask(this, source, htmlCopy.modificationTime, htmlCopy.getValue(HtmlEntry.RESOLVED_UNIT)), false);
+  }
+
+  /**
    * Create a [ResolveHtmlTask] for the given source, marking the resolved unit as being
    * in-process.
    *
    * @param source the source whose content is to be resolved
    * @param htmlEntry the entry for the source
    * @return task data representing the created task
    */
   AnalysisContextImpl_TaskData _createResolveHtmlTask(Source source, HtmlEntry htmlEntry) {
     if (htmlEntry.getState(HtmlEntry.PARSED_UNIT) != CacheState.VALID) {
       return _createParseHtmlTask(source, htmlEntry);
     }
     HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
     htmlCopy.setState(HtmlEntry.RESOLVED_UNIT, CacheState.IN_PROCESS);
     _cache.put(source, htmlCopy);
-    return new AnalysisContextImpl_TaskData(new ResolveHtmlTask(this, source, htmlCopy.modificationTime, htmlCopy.getValue(HtmlEntry.PARSED_UNIT)), false, null);
+    return new AnalysisContextImpl_TaskData(new ResolveHtmlTask(this, source, htmlCopy.modificationTime, htmlCopy.getValue(HtmlEntry.PARSED_UNIT)), false);
   }
 
   /**
    * Create a [ScanDartTask] for the given source, marking the scan errors as being
    * in-process.
    *
    * @param source the source whose content is to be scanned
    * @param dartEntry the entry for the source
    * @return task data representing the created task
    */
   AnalysisContextImpl_TaskData _createScanDartTask(Source source, DartEntry dartEntry) {
     if (dartEntry.getState(SourceEntry.CONTENT) != CacheState.VALID) {
       return _createGetContentTask(source, dartEntry);
     }
     String content = dartEntry.getValue(SourceEntry.CONTENT);
     DartEntryImpl dartCopy = dartEntry.writableCopy;
     dartCopy.setState(SourceEntry.CONTENT, CacheState.FLUSHED);
     dartCopy.setState(DartEntry.SCAN_ERRORS, CacheState.IN_PROCESS);
     _cache.put(source, dartCopy);
-    return new AnalysisContextImpl_TaskData(new ScanDartTask(this, source, dartCopy.modificationTime, content), false, null);
+    return new AnalysisContextImpl_TaskData(new ScanDartTask(this, source, dartCopy.modificationTime, content), false);
   }
 
   /**
    * 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) {
@@ skipping 34 matching lines @@
         return null;
       }
       return ChangeNoticeImpl.EMPTY_ARRAY;
     }
     List<ChangeNotice> notices = new List.from(_pendingNotices.values);
     _pendingNotices.clear();
     return notices;
   }
 
   /**
-   * 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 resolving the
-   * directives in the source if they are 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 parsed
-   */
-  Object _getDartDependencyData(Source source, DartEntry dartEntry, DataDescriptor descriptor) {
-    dartEntry = _cacheDartDependencyData(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 resolving the directives in the source if they
-   * are 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 parsed
-   */
-  Object _getDartDependencyData2(Source source, DataDescriptor descriptor, Object defaultValue) {
-    DartEntry dartEntry = _getReadableDartEntry(source);
-    if (dartEntry == null) {
-      return defaultValue;
-    }
-    try {
-      return _getDartDependencyData(source, dartEntry, descriptor);
-    } on ObsoleteSourceAnalysisException catch (exception) {
-      AnalysisEngine.instance.logger.logInformation2("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
    * @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 148 matching lines @@
       AnalysisEngine.instance.logger.logInformation2("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.
    *
+   * <b>Note:</b> This method cannot be used in an async environment.
+   *
    * @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
    *           resolved
    */
   Object _getDartVerificationData(Source unitSource, Source librarySource, DartEntry dartEntry, DataDescriptor descriptor) {
     dartEntry = _cacheDartVerificationData(unitSource, librarySource, dartEntry, descriptor);
@@ skipping 91 matching lines @@
     //
     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) {
-      AnalysisContextImpl_TaskData taskData = _getNextNondependentAnalysisTask(source, true, hintsEnabled, sdkErrorsEnabled);
+      AnalysisContextImpl_TaskData taskData = _getNextAnalysisTaskForSource(source, _cache.get(source), true, 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) {
-      AnalysisContextImpl_TaskData taskData = _getNextNondependentAnalysisTask(source, false, hintsEnabled, sdkErrorsEnabled);
+    List<Source> sourcesToRemove = new List<Source>();
+    WorkManager_WorkIterator sources = _workManager.iterator();
+    while (sources.hasNext) {
+      Source source = sources.next();
+      AnalysisContextImpl_TaskData taskData = _getNextAnalysisTaskForSource(source, _cache.get(source), false, hintsEnabled, sdkErrorsEnabled);
       AnalysisTask task = taskData.task;
       if (task != null) {
         return task;
       } else if (taskData.isBlocked) {
         hasBlockedTask = true;
       } else {
-        _workManager.remove(source);
+        sourcesToRemove.add(source);
       }
-      source = _workManager.nextSource;
+    }
+    int count = sourcesToRemove.length;
+    for (int i = 0; i < count; i++) {
+      _workManager.remove(sourcesToRemove[i]);
     }
     //      //
     //      // 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();
     //        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) {
+      // All of the analysis work is blocked waiting for an asynchronous task to complete.
       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
    */
   AnalysisContextImpl_TaskData _getNextAnalysisTaskForSource(Source source, SourceEntry sourceEntry, bool isPriority, bool hintsEnabled, bool sdkErrorsEnabled) {
     if (sourceEntry == null) {
-      return new AnalysisContextImpl_TaskData(null, false, null);
+      return new AnalysisContextImpl_TaskData(null, false);
     }
     CacheState contentState = sourceEntry.getState(SourceEntry.CONTENT);
     if (identical(contentState, CacheState.INVALID)) {
       return _createGetContentTask(source, sourceEntry);
     } else if (identical(contentState, CacheState.IN_PROCESS)) {
       // We are already 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);
+      return new AnalysisContextImpl_TaskData(null, true);
+    } else if (identical(contentState, CacheState.ERROR)) {
+      // We have done all of the analysis we can for this source because we cannot get its content.
+      return new AnalysisContextImpl_TaskData(null, false);
     }
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       CacheState scanErrorsState = dartEntry.getState(DartEntry.SCAN_ERRORS);
       if (identical(scanErrorsState, CacheState.INVALID) || (isPriority && identical(scanErrorsState, CacheState.FLUSHED))) {
         return _createScanDartTask(source, dartEntry);
       }
       CacheState parseErrorsState = dartEntry.getState(DartEntry.PARSE_ERRORS);
       if (identical(parseErrorsState, CacheState.INVALID) || (isPriority && identical(parseErrorsState, CacheState.FLUSHED))) {
         return _createParseDartTask(source, dartEntry);
       }
       if (isPriority && parseErrorsState != CacheState.ERROR) {
         CompilationUnit parseUnit = dartEntry.anyParsedCompilationUnit;
         if (parseUnit == null) {
           return _createParseDartTask(source, dartEntry);
         }
       }
-      CacheState exportState = dartEntry.getState(DartEntry.EXPORTED_LIBRARIES);
-      if (identical(exportState, CacheState.INVALID) || (isPriority && identical(exportState, CacheState.FLUSHED))) {
-        return _createResolveDartDependenciesTask(source, dartEntry);
-      }
       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 AnalysisContextImpl_TaskData(new ResolveDartLibraryTask(this, source, librarySource), false, null);
+            return new AnalysisContextImpl_TaskData(new ResolveDartLibraryTask(this, source, librarySource), false);
           }
           CacheState resolvedUnitState = dartEntry.getStateInLibrary(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.setStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource, CacheState.IN_PROCESS);
             _cache.put(source, dartCopy);
             //return new ResolveDartUnitTask(this, source, libraryElement);
-            return new AnalysisContextImpl_TaskData(new ResolveDartLibraryTask(this, source, librarySource), false, null);
+            return new AnalysisContextImpl_TaskData(new ResolveDartLibraryTask(this, source, librarySource), false);
           }
           if (sdkErrorsEnabled || !source.isInSystemLibrary) {
             CacheState verificationErrorsState = dartEntry.getStateInLibrary(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.setStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.IN_PROCESS);
                 _cache.put(source, dartCopy);
-                return new AnalysisContextImpl_TaskData(new GenerateDartErrorsTask(this, source, libraryElement), false, null);
+                return new AnalysisContextImpl_TaskData(new GenerateDartErrorsTask(this, source, libraryElement), false);
               }
             }
             if (hintsEnabled) {
               CacheState hintsState = dartEntry.getStateInLibrary(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.setStateInLibrary(DartEntry.HINTS, librarySource, CacheState.IN_PROCESS);
                   _cache.put(source, dartCopy);
-                  return new AnalysisContextImpl_TaskData(new GenerateDartHintsTask(this, libraryElement), false, null);
+                  return new AnalysisContextImpl_TaskData(new GenerateDartHintsTask(this, libraryElement), false);
                 }
               }
             }
           }
         }
       }
     } 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))) {
         return _createParseHtmlTask(source, htmlEntry);
       }
       if (isPriority && parseErrorsState != CacheState.ERROR) {
         ht.HtmlUnit parsedUnit = htmlEntry.anyParsedUnit;
         if (parsedUnit == null) {
           return _createParseHtmlTask(source, htmlEntry);
         }
       }
       CacheState resolvedUnitState = htmlEntry.getState(HtmlEntry.RESOLVED_UNIT);
       if (identical(resolvedUnitState, CacheState.INVALID) || (isPriority && identical(resolvedUnitState, CacheState.FLUSHED))) {
         return _createResolveHtmlTask(source, htmlEntry);
       }
+      //
       // Angular support
+      //
       if (_options.analyzeAngular) {
-        // try to resolve as an Angular entry point
+        // Try to resolve the HTML as an Angular entry point.
         CacheState angularEntryState = htmlEntry.getState(HtmlEntry.ANGULAR_ENTRY);
         if (identical(angularEntryState, CacheState.INVALID)) {
-          if (htmlEntry.getState(HtmlEntry.RESOLVED_UNIT) != CacheState.VALID) {
-            return _createResolveHtmlTask(source, htmlEntry);
-          }
-          HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
-          htmlCopy.setState(HtmlEntry.ANGULAR_ENTRY, CacheState.IN_PROCESS);
-          _cache.put(source, htmlCopy);
-          return new AnalysisContextImpl_TaskData(new ResolveAngularEntryHtmlTask(this, source, htmlCopy.modificationTime, htmlCopy.getValue(HtmlEntry.RESOLVED_UNIT)), false, null);
+          return _createResolveAngularEntryHtmlTask(source, htmlEntry);
         }
-        // try to resolve as an Angular application part
+        // Try to resolve the HTML as an Angular application part.
         CacheState angularErrorsState = htmlEntry.getState(HtmlEntry.ANGULAR_ERRORS);
         if (identical(angularErrorsState, CacheState.INVALID)) {
-          if (htmlEntry.getState(HtmlEntry.RESOLVED_UNIT) != CacheState.VALID) {
-            return _createResolveHtmlTask(source, htmlEntry);
-          }
-          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 AnalysisContextImpl_TaskData(new ResolveAngularComponentTemplateTask(this, source, htmlCopy.modificationTime, htmlCopy.getValue(HtmlEntry.RESOLVED_UNIT), component, application), false, null);
+          return _createResolveAngularComponentTemplateTask(source, htmlEntry);
         }
       }
     }
-    return new AnalysisContextImpl_TaskData(null, false, null);
-  }
-
-  AnalysisContextImpl_TaskData _getNextNondependentAnalysisTask(Source source, bool isPriority, bool hintsEnabled, bool sdkErrorsEnabled) {
-    AnalysisContextImpl_TaskData taskData = _getNextAnalysisTaskForSource(source, _cache.get(source), isPriority, hintsEnabled, sdkErrorsEnabled);
-    if (taskData.task != null || taskData.isBlocked) {
-      return taskData;
-    }
-    while (taskData.dependentSource != null) {
-      taskData = _getNextAnalysisTaskForSource(source, _cache.get(source), isPriority, hintsEnabled, sdkErrorsEnabled);
-      if (taskData.task != null || taskData.isBlocked) {
-        return taskData;
-      }
-    }
-    return new AnalysisContextImpl_TaskData(null, false, null);
+    return new AnalysisContextImpl_TaskData(null, false);
   }
 
   /**
    * 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 704 matching lines @@
     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}");
         }
       }
+      _removeFromParts(source, dartEntry);
       DartEntryImpl dartCopy = dartEntry.writableCopy;
       if (thrownException == null) {
         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);
         }
+        List<Source> newParts = task.includedSources;
+        for (int i = 0; i < newParts.length; i++) {
+          Source partSource = newParts[i];
+          DartEntry partEntry = _getReadableDartEntry(partSource);
+          if (partEntry != null && partEntry != dartEntry) {
+            DartEntryImpl partCopy = partEntry.writableCopy;
+            partCopy.addContainingLibrary(source);
+            _cache.put(partSource, partCopy);
+          }
+        }
         dartCopy.setValue(DartEntry.PARSED_UNIT, task.compilationUnit);
         dartCopy.setValue(DartEntry.PARSE_ERRORS, task.errors);
+        dartCopy.setValue(DartEntry.EXPORTED_LIBRARIES, task.exportedSources);
+        dartCopy.setValue(DartEntry.IMPORTED_LIBRARIES, task.importedSources);
+        dartCopy.setValue(DartEntry.INCLUDED_PARTS, newParts);
         _cache.storedAst(source);
         ChangeNoticeImpl notice = _getNotice(source);
         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);
@@ skipping 281 matching lines @@
       _cache.put(source, htmlCopy);
       htmlEntry = htmlCopy;
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return htmlEntry;
   }
 
   /**
-   * Record the results produced by performing a [ResolveDartDependenciesTask]. 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 _recordResolveDartDependenciesTaskResults(ResolveDartDependenciesTask 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 resolve Dart dependencies in a non-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}");
-        }
-      }
-      _removeFromParts(source, dartEntry);
-      DartEntryImpl dartCopy = dartEntry.writableCopy;
-      if (thrownException == null) {
-        List<Source> newParts = task.includedSources;
-        for (int i = 0; i < newParts.length; i++) {
-          Source partSource = newParts[i];
-          DartEntry partEntry = _getReadableDartEntry(partSource);
-          if (partEntry != null && partEntry != dartEntry) {
-            DartEntryImpl partCopy = partEntry.writableCopy;
-            partCopy.addContainingLibrary(source);
-            _cache.put(partSource, partCopy);
-          }
-        }
-        dartCopy.setValue(DartEntry.EXPORTED_LIBRARIES, task.exportedSources);
-        dartCopy.setValue(DartEntry.IMPORTED_LIBRARIES, task.importedSources);
-        dartCopy.setValue(DartEntry.INCLUDED_PARTS, newParts);
-        dartCopy.setValue(DartEntry.DIRECTIVE_ERRORS, task.errors);
-      } else {
-        dartCopy.recordDependencyError();
-      }
-      dartCopy.exception = thrownException;
-      _cache.put(source, dartCopy);
-      dartEntry = dartCopy;
-    } else {
-      _logInformation2("Dependency resolution 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.recordDependencyNotInProcess();
-        _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.setState(DartEntry.EXPORTED_LIBRARIES, CacheState.ERROR);
-        dartCopy.setState(DartEntry.IMPORTED_LIBRARIES, CacheState.ERROR);
-        dartCopy.setState(DartEntry.INCLUDED_PARTS, CacheState.ERROR);
-      }
-      dartCopy.exception = thrownException;
-      _cache.put(source, dartCopy);
-      dartEntry = dartCopy;
-    }
-    if (thrownException != null) {
-      throw thrownException;
-    }
-    return dartEntry;
-  }
-
-  /**
    * 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
    */
   DartEntry _recordResolveDartUnitTaskResults(ResolveDartUnitTask task) {
     Source unitSource = task.source;
     Source librarySource = task.librarySource;
@@ skipping 462 matching lines @@
   @override
   HtmlEntry visitParseHtmlTask(ParseHtmlTask task) => AnalysisContextImpl_this._recordParseHtmlTaskResults(task);
 
   @override
   HtmlEntry visitResolveAngularComponentTemplateTask(ResolveAngularComponentTemplateTask task) => AnalysisContextImpl_this._recordResolveAngularComponentTemplateTaskResults(task);
 
   @override
   HtmlEntry visitResolveAngularEntryHtmlTask(ResolveAngularEntryHtmlTask task) => AnalysisContextImpl_this._recordResolveAngularEntryHtmlTaskResults(task);
 
   @override
-  DartEntry visitResolveDartDependenciesTask(ResolveDartDependenciesTask task) => AnalysisContextImpl_this._recordResolveDartDependenciesTaskResults(task);
-
-  @override
   DartEntry visitResolveDartLibraryTask(ResolveDartLibraryTask task) => AnalysisContextImpl_this.recordResolveDartLibraryTaskResults(task);
 
   @override
   DartEntry visitResolveDartUnitTask(ResolveDartUnitTask task) => AnalysisContextImpl_this._recordResolveDartUnitTaskResults(task);
 
   @override
   HtmlEntry visitResolveHtmlTask(ResolveHtmlTask task) => AnalysisContextImpl_this._recordResolveHtmlTaskResults(task);
 
   @override
   DartEntry visitScanDartTask(ScanDartTask task) => AnalysisContextImpl_this._recordScanDartTaskResults(task);
@@ skipping 31 matching lines @@
  * 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;
+  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) {
+  AnalysisContextImpl_TaskData(AnalysisTask task, bool blocked) {
+    this.task = task;
     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;
+  List<AnalysisError> errors;
 
   /**
    * The line information associated with the errors, or `null` if there are no errors.
    */
-  final LineInfo lineInfo;
+  LineInfo lineInfo;
 
   /**
    * Initialize an newly created error info with the errors and line information
    *
    * @param errors the errors as a result of analysis
    * @param lineinfo the line info for the errors
    */
-  AnalysisErrorInfoImpl(this.errors, this.lineInfo);
+  AnalysisErrorInfoImpl(List<AnalysisError> errors, LineInfo lineInfo) {
+    this.errors = errors;
+    this.lineInfo = lineInfo;
+  }
 }
 
 /**
  * Instances of the class `AnalysisOptions` represent a set of analysis options used to
  * control the behavior of an analysis context.
  */
 class AnalysisOptionsImpl implements AnalysisOptions {
   /**
    * The maximum number of sources for which data should be kept in the cache.
    */
@@ skipping 75 matching lines @@
 }
 
 /**
  * Instances of the class `ChangeNoticeImpl` represent a change to the analysis results
  * associated with a given source.
  */
 class ChangeNoticeImpl implements ChangeNotice {
   /**
    * The source for which the result is being reported.
    */
-  final Source source;
+  Source source;
 
   /**
    * The fully resolved AST that changed as a result of the analysis, or `null` if the AST was
    * not changed.
    */
   CompilationUnit compilationUnit;
 
   /**
    * The fully resolved HTML that changed as a result of the analysis, or `null` if the HTML
    * was not changed.
@@ skipping 14 matching lines @@
   /**
    * An empty array of change notices.
    */
   static List<ChangeNoticeImpl> EMPTY_ARRAY = new List<ChangeNoticeImpl>(0);
 
   /**
    * Initialize a newly created notice associated with the given source.
    *
    * @param source the source for which the change is being reported
    */
-  ChangeNoticeImpl(this.source);
+  ChangeNoticeImpl(Source source) {
+    this.source = source;
+  }
 
   @override
   List<AnalysisError> get errors => _errors;
 
   @override
   LineInfo get lineInfo => _lineInfo;
 
   /**
    * 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.
@@ skipping 188 matching lines @@
   Namespace getPublicNamespace(LibraryElement library) {
     Source source = library.source;
     if (source.isInSystemLibrary) {
       return _sdkAnalysisContext.getPublicNamespace(library);
     } else {
       return super.getPublicNamespace(library);
     }
   }
 
   @override
-  Namespace getPublicNamespace2(Source source) {
-    if (source.isInSystemLibrary) {
-      return _sdkAnalysisContext.getPublicNamespace2(source);
-    } else {
-      return super.getPublicNamespace2(source);
-    }
-  }
-
-  @override
   CompilationUnit getResolvedCompilationUnit(Source unitSource, LibraryElement library) {
     if (unitSource.isInSystemLibrary) {
       return _sdkAnalysisContext.getResolvedCompilationUnit(unitSource, library);
     } else {
       return super.getResolvedCompilationUnit(unitSource, library);
     }
   }
 
   @override
   CompilationUnit getResolvedCompilationUnit2(Source unitSource, Source librarySource) {
@@ skipping 224 matching lines @@
    */
   static IncrementalAnalysisCache verifyStructure(IncrementalAnalysisCache cache, Source source, CompilationUnit unit) {
     if (cache != null && unit != null && cache.source == source) {
       if (!AstComparator.equalUnits(cache.resolvedUnit, unit)) {
         return null;
       }
     }
     return cache;
   }
 
-  final Source librarySource;
+  Source librarySource;
 
-  final Source source;
+  Source source;
 
-  final String oldContents;
+  String oldContents;
 
-  final CompilationUnit resolvedUnit;
+  CompilationUnit resolvedUnit;
 
   String _newContents;
 
   int _offset = 0;
 
   int _oldLength = 0;
 
   int _newLength = 0;
 
-  IncrementalAnalysisCache(this.librarySource, this.source, this.resolvedUnit, this.oldContents, String newContents, int offset, int oldLength, int newLength) {
+  IncrementalAnalysisCache(Source librarySource, Source source, CompilationUnit resolvedUnit, String oldContents, String newContents, int offset, int oldLength, int newLength) {
+    this.librarySource = librarySource;
+    this.source = source;
+    this.resolvedUnit = resolvedUnit;
+    this.oldContents = oldContents;
     this._newContents = newContents;
     this._offset = offset;
     this._oldLength = oldLength;
     this._newLength = newLength;
   }
 
   /**
    * Return the current contents for the receiver's source.
    *
    * @return the contents (not `null`)
@@ skipping 459 matching lines @@
       return _basis.getModificationStamp(source);
     } finally {
       instrumentation.log();
     }
   }
 
   @override
   Namespace getPublicNamespace(LibraryElement library) => _basis.getPublicNamespace(library);
 
   @override
-  Namespace getPublicNamespace2(Source source) => _basis.getPublicNamespace2(source);
-
-  @override
   List<Source> get refactoringUnsafeSources {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getRefactoringUnsafeSources");
     _checkThread(instrumentation);
     try {
       instrumentation.metric3("contextId", _contextId);
       return _basis.refactoringUnsafeSources;
     } finally {
       instrumentation.log();
     }
   }
@@ skipping 325 matching lines @@
   /**
    * Return a namespace containing mappings for all of the public names defined by the given
    * library.
    *
    * @param library the library whose public namespace is to be returned
    * @return the public namespace of the given library
    */
   Namespace getPublicNamespace(LibraryElement library);
 
   /**
-   * Return a namespace containing mappings for all of the public names defined by the library
-   * defined by the given source.
-   *
-   * @param source the source defining the library whose public namespace is to be returned
-   * @return the public namespace corresponding to the library defined by the given source
-   * @throws AnalysisException if the public namespace could not be computed
-   */
-  Namespace getPublicNamespace2(Source source);
-
-  /**
    * Returns a statistics about this context.
    */
   AnalysisContentStatistics get statistics;
 
   /**
    * 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
@@ skipping 241 matching lines @@
   }
 }
 
 /**
  * Instances of the class `ResolvableCompilationUnit` represent a compilation unit that is not
  * referenced by any other objects and for which we have modification stamp information. It is used
  * by the [LibraryResolver] to resolve a library.
  */
 class ResolvableCompilationUnit extends TimestampedData<CompilationUnit> {
   /**
+   * The source of the compilation unit.
+   */
+  Source _source;
+
+  /**
    * Initialize a newly created holder to hold the given values.
    *
    * @param modificationTime the modification time of the source from which the AST was created
    * @param unit the AST that was created from the source
    */
-  ResolvableCompilationUnit(int modificationTime, CompilationUnit unit) : super(modificationTime, unit);
+  ResolvableCompilationUnit.con1(int modificationTime, CompilationUnit unit) : super(modificationTime, unit);
+
+  /**
+   * Initialize a newly created holder to hold the given values.
+   *
+   * @param modificationTime the modification time of the source from which the AST was created
+   * @param unit the AST that was created from the source
+   * @param source the source of the compilation unit
+   */
+  ResolvableCompilationUnit.con2(int modificationTime, CompilationUnit unit, Source source) : super(modificationTime, unit) {
+    this._source = source;
+  }
 
   /**
    * Return the AST that was created from the source.
    *
    * @return the AST that was created from the source
    */
   CompilationUnit get compilationUnit => data;
+
+  /**
+   * Return the source of the compilation unit.
+   *
+   * @return the source of the compilation unit
+   */
+  Source get source => _source;
 }
 
 /**
  * Instances of the class `ResolvableHtmlUnit` represent an HTML unit that is not referenced
  * by any other objects and for which we have modification stamp information. It is used by the
  * [ResolveHtmlTask] to resolve an HTML source.
  */
 class ResolvableHtmlUnit extends TimestampedData<ht.HtmlUnit> {
   /**
    * Initialize a newly created holder to hold the given values.
    *
    * @param modificationTime the modification time of the source from which the AST was created
    * @param unit the AST that was created from the source
    */
   ResolvableHtmlUnit(int modificationTime, ht.HtmlUnit unit) : super(modificationTime, unit);
 
   /**
    * Return the AST that was created from the source.
    *
    * @return the AST that was created from the source
    */
   ht.HtmlUnit get compilationUnit => data;
 }
 
 /**
  * The enumerated type `Priority` defines the priority levels used to return sources in an
- * optimal order.
+ * optimal order. A smaller ordinal value equates to a higher priority.
  */
 class SourcePriority extends Enum<SourcePriority> {
   /**
    * Used for a Dart source that is known to be a part contained in a library that was recently
    * resolved. These parts are given a higher priority because there is a high probability that
    * their AST structure is still in the cache and therefore would not need to be re-created.
    */
   static final SourcePriority PRIORITY_PART = new SourcePriority('PRIORITY_PART', 0);
 
   /**
    * Used for a Dart source that is known to be a library.
    */
   static final SourcePriority LIBRARY = new SourcePriority('LIBRARY', 1);
 
   /**
-   * Used for a Dart source that is known to be a part but whose library has not yet been
-   * resolved.
-   */
-  static final SourcePriority NORMAL_PART = new SourcePriority('NORMAL_PART', 2);
-
-  /**
    * Used for a Dart source whose kind is unknown.
    */
-  static final SourcePriority UNKNOWN = new SourcePriority('UNKNOWN', 3);
+  static final SourcePriority UNKNOWN = new SourcePriority('UNKNOWN', 2);
+
+  /**
+   * Used for a Dart source that is known to be a part but whose library has not yet been resolved.
+   */
+  static final SourcePriority NORMAL_PART = new SourcePriority('NORMAL_PART', 3);
 
   /**
    * Used for an HTML source.
    */
   static final SourcePriority HTML = new SourcePriority('HTML', 4);
 
-  static final List<SourcePriority> values = [PRIORITY_PART, LIBRARY, NORMAL_PART, UNKNOWN, HTML];
+  static final List<SourcePriority> values = [PRIORITY_PART, LIBRARY, UNKNOWN, NORMAL_PART, HTML];
 
   SourcePriority(String name, int ordinal) : super(name, ordinal);
 }
 
 /**
  * Instances of the class `TimestampedData` represent analysis data for which we have a
  * modification time.
  */
 class TimestampedData<E> {
   /**
    * The modification time of the source from which the data was created.
    */
-  final int modificationTime;
+  int modificationTime = 0;
 
   /**
    * The data that was created from the source.
    */
-  final E data;
+  E data;
 
   /**
    * Initialize a newly created holder to hold the given values.
    *
    * @param modificationTime the modification time of the source from which the data was created
    * @param unit the data that was created from the source
    */
-  TimestampedData(this.modificationTime, this.data);
+  TimestampedData(int modificationTime, E data) {
+    this.modificationTime = modificationTime;
+    this.data = data;
+  }
 }
 
 /**
  * Instances of the class `WorkManager` manage a list of sources that need to have analysis
  * work performed on them.
  */
 class WorkManager {
   /**
    * An array containing the various queues is priority order.
    */
   List<List<Source>> _workQueues;
 
   /**
    * Initialize a newly created manager to have no work queued up.
    */
   WorkManager() {
     int queueCount = SourcePriority.values.length;
     _workQueues = new List<List>(queueCount);
     for (int i = 0; i < queueCount; i++) {
       _workQueues[i] = new List<Source>();
     }
   }
 
   /**
    * Record that the given source needs to be analyzed. The priority level is used to control when
-   * the source will be analyzed with respect to other sources.
+   * the source will be analyzed with respect to other sources. If the source was previously added
+   * then it's priority is updated. If it was previously added with the same priority then it's
+   * position in the queue is unchanged.
    *
    * @param source the source that needs to be analyzed
    * @param priority the priority level of the source
    */
   void add(Source source, SourcePriority priority) {
-    // TODO(brianwilkerson) Optimize the order of the libraries so that libraries that depend on
-    // other libraries get analyzed after the other libraries.
     int queueCount = _workQueues.length;
     int ordinal = priority.ordinal;
     for (int i = 0; i < queueCount; i++) {
       List<Source> queue = _workQueues[i];
       if (i == ordinal) {
         if (!queue.contains(source)) {
           queue.add(source);
         }
       } else {
         queue.remove(source);
       }
     }
   }
 
   /**
-   * Return the next source for which some analysis work needs to be done.
+   * Record that the given source needs to be analyzed. The priority level is used to control when
+   * the source will be analyzed with respect to other sources. If the source was previously added
+   * then it's priority is updated. In either case, it will be analyzed before other sources of the
+   * same priority.
    *
-   * @return the next source for which some analysis work needs to be done
+   * @param source the source that needs to be analyzed
+   * @param priority the priority level of the source
    */
-  Source get nextSource {
+  void addFirst(Source source, SourcePriority priority) {
     int queueCount = _workQueues.length;
+    int ordinal = priority.ordinal;
     for (int i = 0; i < queueCount; i++) {
       List<Source> queue = _workQueues[i];
-      if (!queue.isEmpty) {
-        return queue[0];
+      if (i == ordinal) {
+        queue.remove(source);
+        queue.insert(0, source);
+      } else {
+        queue.remove(source);
       }
     }
-    return null;
   }
 
   /**
+   * Return an iterator that can be used to access the sources to be analyzed in the order in which
+   * they should be analyzed.
+   *
+   * <b>Note:</b> As with other iterators, no sources can be added or removed from this work manager
+   * while the iterator is being used. Unlike some implementations, however, the iterator will not
+   * detect when this requirement has been violated; it might work correctly, it might return the
+   * wrong source, or it might throw an exception.
+   *
+   * @return an iterator that can be used to access the next source to be analyzed
+   */
+  WorkManager_WorkIterator iterator() => new WorkManager_WorkIterator(this);
+
+  /**
    * Record that the given source is fully analyzed.
    *
    * @param source the source that is fully analyzed
    */
   void remove(Source source) {
     int queueCount = _workQueues.length;
     for (int i = 0; i < queueCount; i++) {
       _workQueues[i].remove(source);
     }
   }
 }
 
 /**
+ * Instances of the class `WorkIterator` implement an iterator that returns the sources in a
+ * work manager in the order in which they are to be analyzed.
+ */
+class WorkManager_WorkIterator {
+  final WorkManager WorkManager_this;
+
+  /**
+   * The index of the work queue through which we are currently iterating.
+   */
+  int _queueIndex = 0;
+
+  /**
+   * The index of the next element of the work queue to be returned.
+   */
+  int _index = -1;
+
+  /**
+   * Initialize a newly created iterator to be ready to return the first element in the iteration.
+   */
+  WorkManager_WorkIterator(this.WorkManager_this) {
+    _advance();
+  }
+
+  /**
+   * Return `true` if there is another [Source] available for processing.
+   *
+   * @return `true` if there is another [Source] available for processing
+   */
+  bool get hasNext => _queueIndex < _workQueues.length;
+
+  /**
+   * Return the next [Source] available for processing and advance so that the returned
+   * source will not be returned again.
+   *
+   * @return the next [Source] available for processing
+   */
+  Source next() {
+    if (!hasNext) {
+      throw new NoSuchElementException();
+    }
+    Source source = WorkManager_this._workQueues[_queueIndex][_index];
+    _advance();
+    return source;
+  }
+
+  /**
+   * Increment the [index] and [queueIndex] so that they are either indicating the
+   * next source to be returned or are indicating that there are no more sources to be returned.
+   */
+  void _advance() {
+    _index++;
+    if (_index >= WorkManager_this._workQueues[_queueIndex].length) {
+      _index = 0;
+      _queueIndex++;
+      while (_queueIndex < _workQueues.length && WorkManager_this._workQueues[_queueIndex].isEmpty) {
+        _queueIndex++;
+      }
+    }
+  }
+}
+
+/**
  * An [Expression] with optional [AngularFilterNode]s.
  */
 class AngularExpression {
   /**
    * The [Expression] to apply filters to.
    */
-  final Expression expression;
+  Expression expression;
 
   /**
    * The filters to apply.
    */
-  final List<AngularFilterNode> filters;
+  List<AngularFilterNode> filters;
 
-  AngularExpression(this.expression, this.filters);
+  AngularExpression(Expression expression, List<AngularFilterNode> filters) {
+    this.expression = expression;
+    this.filters = filters;
+  }
 
   /**
    * Return the offset of the character immediately following the last character of this node's
    * source range. This is equivalent to `node.getOffset() + node.getLength()`.
    *
    * @return the offset of the character just past the node's source range
    */
   int get end {
     if (filters.isEmpty) {
       return expression.end;
@@ skipping 33 matching lines @@
   int get offset => expression.offset;
 }
 
 /**
  * Angular filter argument.
  */
 class AngularFilterArgument {
   /**
    * The [TokenType#COLON] token.
    */
-  final Token token;
+  Token token;
 
   /**
    * The argument expression.
    */
-  final Expression expression;
+  Expression expression;
 
   /**
    * The optional sub-[Expression]s.
    */
   List<Expression> subExpressions = Expression.EMPTY_ARRAY;
 
-  AngularFilterArgument(this.token, this.expression);
+  AngularFilterArgument(Token token, Expression expression) {
+    this.token = token;
+    this.expression = expression;
+  }
 }
 
 /**
  * Angular filter node.
  */
 class AngularFilterNode {
   /**
    * The [TokenType#BAR] token.
    */
-  final Token token;
+  Token token;
 
   /**
    * The name of the filter.
    */
-  final SimpleIdentifier name;
+  SimpleIdentifier name;
 
   /**
    * The arguments for this filter.
    */
-  final List<AngularFilterArgument> arguments;
+  List<AngularFilterArgument> arguments;
 
-  AngularFilterNode(this.token, this.name, this.arguments);
+  AngularFilterNode(Token token, SimpleIdentifier name, List<AngularFilterArgument> arguments) {
+    this.token = token;
+    this.name = name;
+    this.arguments = arguments;
+  }
 }
 
 /**
  * Instances of the class [AngularHtmlUnitResolver] resolve Angular specific expressions.
  */
 class AngularHtmlUnitResolver extends ht.RecursiveXmlVisitor<Object> {
   static String _NG_APP = "ng-app";
 
   /**
    * Checks if given [Element] is an artificial local variable and returns corresponding
@@ skipping 785 matching lines @@
   int get offset => expression.offset;
 }
 
 /**
  * Abstract Angular specific [XmlExpression].
  */
 abstract class AngularXmlExpression extends ht.XmlExpression {
   /**
    * The expression that is enclosed between the delimiters.
    */
-  final AngularExpression expression;
+  AngularExpression expression;
 
-  AngularXmlExpression(this.expression);
+  AngularXmlExpression(AngularExpression expression) {
+    this.expression = expression;
+  }
 
   @override
   ht.XmlExpression_Reference getReference(int offset) {
     // main expression
     ht.XmlExpression_Reference reference = _getReferenceAtNode(expression.expression, offset);
     if (reference != null) {
       return reference;
     }
     // filters
     for (AngularFilterNode filter in expression.filters) {
@@ skipping 312 matching lines @@
 }
 
 /**
  * The abstract class `AnalysisTask` defines the behavior of objects used to perform an
  * analysis task.
  */
 abstract class AnalysisTask {
   /**
    * The context in which the task is to be performed.
    */
-  final InternalAnalysisContext context;
+  InternalAnalysisContext context;
 
   /**
    * The exception that was thrown while performing this task, or `null` if the task completed
    * successfully.
    */
   AnalysisException _thrownException;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    */
-  AnalysisTask(this.context);
+  AnalysisTask(InternalAnalysisContext context) {
+    this.context = context;
+  }
 
   /**
    * Use the given visitor to visit this task.
    *
    * @param visitor the visitor that should be used to visit this task
    * @return the value returned by the visitor
    * @throws AnalysisException if the visitor throws the exception
    */
   accept(AnalysisTaskVisitor visitor);
 
@@ skipping 128 matching lines @@
   /**
    * Visit a [ResolveAngularEntryHtmlTask].
    *
    * @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 visitResolveAngularEntryHtmlTask(ResolveAngularEntryHtmlTask task);
 
   /**
-   * Visit a [ResolveDartDependenciesTask].
-   *
-   * @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 visitResolveDartDependenciesTask(ResolveDartDependenciesTask task);
-
-  /**
    * Visit a [ResolveDartLibraryTask].
    *
    * @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 visitResolveDartLibraryTask(ResolveDartLibraryTask task);
 
   /**
    * Visit a [ResolveDartUnitTask].
@@ skipping 24 matching lines @@
 }
 
 /**
  * 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.
    */
-  final Source source;
+  Source source;
 
   /**
    * The element model for the library containing the source.
    */
-  final LibraryElement libraryElement;
+  LibraryElement libraryElement;
 
   /**
    * The time at which the contents of the source were last modified.
    */
   int _modificationTime = -1;
 
   /**
    * The errors that were generated for the source.
    */
   List<AnalysisError> _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 for which errors and warnings are to be produced
    * @param libraryElement the element model for the library containing the source
    */
-  GenerateDartErrorsTask(InternalAnalysisContext context, this.source, this.libraryElement) : super(context);
+  GenerateDartErrorsTask(InternalAnalysisContext context, Source source, LibraryElement libraryElement) : super(context) {
+    this.source = source;
+    this.libraryElement = libraryElement;
+  }
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitGenerateDartErrorsTask(this);
 
   /**
    * Return the errors that were generated for the source.
    *
    * @return the errors that were generated for the source
    */
   List<AnalysisError> get errors => _errors;
@@ skipping 38 matching lines @@
   }
 }
 
 /**
  * Instances of the class `GenerateDartHintsTask` generate hints for a single Dart library.
  */
 class GenerateDartHintsTask extends AnalysisTask {
   /**
    * The element model for the library being analyzed.
    */
-  final LibraryElement libraryElement;
+  LibraryElement libraryElement;
 
   /**
    * A table mapping the sources that were analyzed to the hints that were generated for the
    * sources.
    */
   Map<Source, TimestampedData<List<AnalysisError>>> _hintMap;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param libraryElement the element model for the library being analyzed
    */
-  GenerateDartHintsTask(InternalAnalysisContext context, this.libraryElement) : super(context);
+  GenerateDartHintsTask(InternalAnalysisContext context, LibraryElement libraryElement) : super(context) {
+    this.libraryElement = libraryElement;
+  }
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitGenerateDartHintsTask(this);
 
   /**
    * Return a table mapping the sources that were analyzed to the hints that were generated for the
    * sources, or `null` if the task has not been performed or if the analysis did not complete
    * normally.
    *
    * @return a table mapping the sources that were analyzed to the hints that were generated for the
@@ skipping 65 matching lines @@
   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;
+  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) {
+  GetContentTask(InternalAnalysisContext context, Source source) : super(context) {
     if (source == null) {
       throw new IllegalArgumentException("Cannot get contents of null source");
     }
+    this.source = source;
   }
 
   @override
   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
@@ skipping 35 matching lines @@
   }
 }
 
 /**
  * Instances of the class `IncrementalAnalysisTask` incrementally update existing analysis.
  */
 class IncrementalAnalysisTask extends AnalysisTask {
   /**
    * The information used to perform incremental analysis.
    */
-  final IncrementalAnalysisCache cache;
+  IncrementalAnalysisCache cache;
 
   /**
    * The compilation unit that was produced by incrementally updating the existing unit.
    */
   CompilationUnit _updatedUnit;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param cache the incremental analysis cache used to perform the analysis
    */
-  IncrementalAnalysisTask(InternalAnalysisContext context, this.cache) : super(context);
+  IncrementalAnalysisTask(InternalAnalysisContext context, IncrementalAnalysisCache cache) : super(context) {
+    this.cache = cache;
+  }
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitIncrementalAnalysisTask(this);
 
   /**
    * Return the compilation unit that was produced by incrementally updating the existing
    * compilation unit, or `null` if the task has not yet been performed, could not be
    * performed, or if an exception occurred.
    *
    * @return the compilation unit
@@ skipping 58 matching lines @@
   }
 }
 
 /**
  * Instances of the class `ParseDartTask` parse a specific source as a Dart file.
  */
 class ParseDartTask extends AnalysisTask {
   /**
    * The source to be parsed.
    */
-  final Source source;
+  Source source;
 
   /**
    * The time at which the contents of the source were last modified.
    */
-  final int modificationTime;
+  int modificationTime = 0;
 
   /**
    * The head of the token stream used for parsing.
    */
   Token _tokenStream;
 
   /**
+   * The line information associated with the source.
+   */
+  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.
+   * A flag indicating whether the source contains a 'library' directive.
    */
-  List<AnalysisError> _errors = AnalysisError.NO_ERRORS;
+  bool _containsLibraryDirective = false;
 
   /**
    * A flag indicating whether the source contains a 'part of' directive.
    */
   bool _containsPartOfDirective = false;
 
   /**
-   * A flag indicating whether the source contains a 'library' directive.
+   * A set containing the sources referenced by 'export' directives.
    */
-  bool _containsLibraryDirective = false;
+  Set<Source> _exportedSources = new Set<Source>();
+
+  /**
+   * A set containing the sources referenced by 'import' directives.
+   */
+  Set<Source> _importedSources = new Set<Source>();
+
+  /**
+   * A set containing the sources referenced by 'part' directives.
+   */
+  Set<Source> _includedSources = new Set<Source>();
+
+  /**
+   * The errors that were produced by scanning and parsing the source.
+   */
+  List<AnalysisError> _errors = AnalysisError.NO_ERRORS;
+
+  /**
+   * The prefix of a URI using the `dart-ext` scheme to reference a native code library.
+   */
+  static String _DART_EXT_SCHEME = "dart-ext:";
 
   /**
    * 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 modificationTime the time at which the contents of the source were last modified
    * @param tokenStream the head of the token stream used for parsing
+   * @param lineInfo the line information associated with the source
    */
-  ParseDartTask(InternalAnalysisContext context, this.source, this.modificationTime, Token tokenStream) : super(context) {
+  ParseDartTask(InternalAnalysisContext context, Source source, int modificationTime, Token tokenStream, LineInfo lineInfo) : super(context) {
+    this.source = source;
+    this.modificationTime = modificationTime;
     this._tokenStream = tokenStream;
+    this._lineInfo = lineInfo;
   }
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitParseDartTask(this);
 
   /**
    * Return the compilation unit that was produced by parsing the source, or `null` if the
    * task has not yet been performed or if an exception occurred.
    *
    * @return the compilation unit that was produced by parsing the source
    */
   CompilationUnit get compilationUnit => _unit;
 
   /**
    * Return the errors that were produced by scanning and parsing the source, or an empty array 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 an array containing the sources referenced by 'export' directives, or an empty array if
+   * the task has not yet been performed or if an exception occurred.
+   *
+   * @return an array containing the sources referenced by 'export' directives
+   */
+  List<Source> get exportedSources => _toArray(_exportedSources);
+
+  /**
+   * Return an array containing the sources referenced by 'import' directives, or an empty array if
+   * the task has not yet been performed or if an exception occurred.
+   *
+   * @return an array containing the sources referenced by 'import' directives
+   */
+  List<Source> get importedSources => _toArray(_importedSources);
+
+  /**
+   * Return an array containing the sources referenced by 'part' directives, or an empty array if
+   * the task has not yet been performed or if an exception occurred.
+   *
+   * @return an array containing the sources referenced by 'part' directives
+   */
+  List<Source> get includedSources => _toArray(_includedSources);
+
+  /**
    * 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 get 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 get hasPartOfDirective => _containsPartOfDirective;
 
   @override
   String get taskDescription {
     if (source == null) {
       return "parse as dart null source";
     }
     return "parse as dart ${source.fullName}";
   }
 
   @override
   void internalPerform() {
-    RecordingErrorListener errorListener = new RecordingErrorListener();
-    InternalAnalysisContext context = this.context;
     //
     // Then parse the token stream.
     //
     TimeCounter_TimeCounterHandle timeCounterParse = PerformanceStatistics.parse.start();
     try {
+      RecordingErrorListener errorListener = new RecordingErrorListener();
       Parser parser = new Parser(source, errorListener);
       parser.parseFunctionBodies = context.analysisOptions.analyzeFunctionBodies;
       _unit = parser.parseCompilationUnit(_tokenStream);
+      _unit.lineInfo = _lineInfo;
       _errors = errorListener.getErrorsForSource(source);
       for (Directive directive in _unit.directives) {
-        if (directive is LibraryDirective) {
+        if (directive is ExportDirective) {
+          Source exportSource = _resolveSource(source, directive, errorListener);
+          if (exportSource != null) {
+            _exportedSources.add(exportSource);
+          }
+        } else if (directive is ImportDirective) {
+          Source importSource = _resolveSource(source, directive, errorListener);
+          if (importSource != null) {
+            _importedSources.add(importSource);
+          }
+        } else if (directive is LibraryDirective) {
           _containsLibraryDirective = true;
+        } else if (directive is PartDirective) {
+          Source partSource = _resolveSource(source, directive, errorListener);
+          if (partSource != null) {
+            _includedSources.add(partSource);
+          }
         } else if (directive is PartOfDirective) {
           _containsPartOfDirective = true;
         }
       }
-      _unit.lineInfo = context.getLineInfo(source);
     } finally {
       timeCounterParse.stop();
     }
   }
+
+  /**
+   * Return the result of resolving the URI of the given URI-based directive against the URI of the
+   * given library, or `null` if the URI is not valid.
+   *
+   * @param librarySource the source representing the library containing the directive
+   * @param directive the directive which URI should be resolved
+   * @param errorListener the error listener to which errors should be reported
+   * @return the result of resolving the URI against the URI of the library
+   */
+  Source _resolveSource(Source librarySource, UriBasedDirective directive, AnalysisErrorListener errorListener) {
+    StringLiteral uriLiteral = directive.uri;
+    if (uriLiteral is StringInterpolation) {
+      errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.URI_WITH_INTERPOLATION, []));
+      return null;
+    }
+    String uriContent = uriLiteral.stringValue.trim();
+    directive.uriContent = uriContent;
+    if (directive is ImportDirective && uriContent.startsWith(_DART_EXT_SCHEME)) {
+      return null;
+    }
+    try {
+      String encodedUriContent = Uri.encodeFull(uriContent);
+      parseUriWithException(encodedUriContent);
+      AnalysisContext analysisContext = context;
+      Source source = analysisContext.sourceFactory.resolveUri(librarySource, encodedUriContent);
+      if (!analysisContext.exists(source)) {
+        errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.URI_DOES_NOT_EXIST, [uriContent]));
+      }
+      directive.source = source;
+      return source;
+    } on URISyntaxException catch (exception) {
+      errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.INVALID_URI, [uriContent]));
+    }
+    return null;
+  }
+
+  /**
+   * Efficiently convert the given set of sources to an array.
+   *
+   * @param sources the set to be converted
+   * @return an array containing all of the sources in the given set
+   */
+  List<Source> _toArray(Set<Source> sources) {
+    int size = sources.length;
+    if (size == 0) {
+      return Source.EMPTY_ARRAY;
+    }
+    return new List.from(sources);
+  }
 }
 
 /**
  * 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;
+  Source source;
 
   /**
    * The time at which the contents of the source were last modified.
    */
-  final int modificationTime;
+  int modificationTime = 0;
 
   /**
    * The contents of the source.
    */
   String _content;
 
   /**
    * The line information that was produced.
    */
   LineInfo _lineInfo;
@@ skipping 24 matching lines @@
   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 modificationTime the time at which the contents of the source were last modified
    * @param content the contents of the source
    */
-  ParseHtmlTask(InternalAnalysisContext context, this.source, this.modificationTime, String content) : super(context) {
+  ParseHtmlTask(InternalAnalysisContext context, Source source, int modificationTime, String content) : super(context) {
+    this.source = source;
+    this.modificationTime = modificationTime;
     this._content = content;
   }
 
   @override
   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.
    *
@@ skipping 93 matching lines @@
 }
 
 /**
  * Instances of the class `ResolveAngularComponentTemplateTask` resolve HTML template
  * referenced by [AngularComponentElement].
  */
 class ResolveAngularComponentTemplateTask extends AnalysisTask {
   /**
    * The source to be resolved.
    */
-  final Source source;
+  Source source;
 
   /**
    * The time at which the contents of the source were last modified.
    */
-  final int modificationTime;
+  int modificationTime = 0;
 
   /**
    * The HTML unit to be resolved.
    */
   ht.HtmlUnit _unit;
 
   /**
    * The [AngularComponentElement] to resolve template for.
    */
   AngularComponentElement _component;
@@ skipping 16 matching lines @@
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be resolved
    * @param modificationTime the time at which the contents of the source were last modified
    * @param unit the HTML unit 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, this.modificationTime, ht.HtmlUnit unit, AngularComponentElement component, AngularApplication application) : super(context) {
+  ResolveAngularComponentTemplateTask(InternalAnalysisContext context, Source source, int modificationTime, ht.HtmlUnit unit, AngularComponentElement component, AngularApplication application) : super(context) {
+    this.source = source;
+    this.modificationTime = modificationTime;
     this._unit = unit;
     this._component = component;
     this._application = application;
   }
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitResolveAngularComponentTemplateTask(this);
 
   List<AnalysisError> get resolutionErrors => _resolutionErrors;
 
@@ skipping 30 matching lines @@
 }
 
 /**
  * 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;
+  Source source;
 
   /**
    * The time at which the contents of the source were last modified.
    */
-  final int modificationTime;
+  int modificationTime = 0;
 
   /**
    * The HTML unit to be resolved.
    */
   ht.HtmlUnit _unit;
 
   /**
    * The listener to record errors.
    */
   RecordingErrorListener _errorListener = new RecordingErrorListener();
@@ skipping 14 matching lines @@
   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 modificationTime the time at which the contents of the source were last modified
    * @param unit the HTML unit to be resolved
    */
-  ResolveAngularEntryHtmlTask(InternalAnalysisContext context, this.source, this.modificationTime, ht.HtmlUnit unit) : super(context) {
+  ResolveAngularEntryHtmlTask(InternalAnalysisContext context, Source source, int modificationTime, ht.HtmlUnit unit) : super(context) {
+    this.source = source;
+    this.modificationTime = modificationTime;
     this._unit = unit;
   }
 
   @override
   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.
    */
@@ skipping 43 matching lines @@
       new AngularHtmlUnitResolver(context, _errorListener, source, lineInfo, _unit).resolveEntryPoint(_application);
     }
     //
     // Remember the resolved unit.
     //
     _resolvedUnit = _unit;
   }
 }
 
 /**
- * Instances of the class `ResolveDartDependenciesTask` resolve the import, export, and part
- * directives in a single source.
- */
-class ResolveDartDependenciesTask extends AnalysisTask {
-  /**
-   * The source containing the directives to be resolved.
-   */
-  final Source source;
-
-  /**
-   * The time at which the contents of the source were last modified.
-   */
-  final int modificationTime;
-
-  /**
-   * The compilation unit used to resolve the dependencies.
-   */
-  CompilationUnit _unit;
-
-  /**
-   * A set containing the sources referenced by 'export' directives.
-   */
-  Set<Source> _exportedSources = new Set<Source>();
-
-  /**
-   * A set containing the sources referenced by 'import' directives.
-   */
-  Set<Source> _importedSources = new Set<Source>();
-
-  /**
-   * A set containing the sources referenced by 'part' directives.
-   */
-  Set<Source> _includedSources = new Set<Source>();
-
-  /**
-   * The errors that were produced by resolving the directives.
-   */
-  List<AnalysisError> _errors = AnalysisError.NO_ERRORS;
-
-  /**
-   * The prefix of a URI using the `dart-ext` scheme to reference a native code library.
-   */
-  static String _DART_EXT_SCHEME = "dart-ext:";
-
-  /**
-   * 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 modificationTime the time at which the contents of the source were last modified
-   * @param unit the compilation unit used to resolve the dependencies
-   */
-  ResolveDartDependenciesTask(InternalAnalysisContext context, this.source, this.modificationTime, CompilationUnit unit) : super(context) {
-    this._unit = unit;
-  }
-
-  @override
-  accept(AnalysisTaskVisitor visitor) => visitor.visitResolveDartDependenciesTask(this);
-
-  /**
-   * Return the errors that were produced by resolving the directives, or an empty array if the task
-   * has not yet been performed or if an exception occurred.
-   *
-   * @return the errors that were produced by resolving the directives.
-   */
-  List<AnalysisError> get errors => _errors;
-
-  /**
-   * Return an array containing the sources referenced by 'export' directives, or an empty array if
-   * the task has not yet been performed or if an exception occurred.
-   *
-   * @return an array containing the sources referenced by 'export' directives
-   */
-  List<Source> get exportedSources => _toArray(_exportedSources);
-
-  /**
-   * Return an array containing the sources referenced by 'import' directives, or an empty array if
-   * the task has not yet been performed or if an exception occurred.
-   *
-   * @return an array containing the sources referenced by 'import' directives
-   */
-  List<Source> get importedSources => _toArray(_importedSources);
-
-  /**
-   * Return an array containing the sources referenced by 'part' directives, or an empty array if
-   * the task has not yet been performed or if an exception occurred.
-   *
-   * @return an array containing the sources referenced by 'part' directives
-   */
-  List<Source> get includedSources => _toArray(_includedSources);
-
-  @override
-  String get taskDescription {
-    if (source == null) {
-      return "resolve dart dependencies null source";
-    }
-    return "resolve dart dependencies ${source.fullName}";
-  }
-
-  @override
-  void internalPerform() {
-    TimeCounter_TimeCounterHandle timeCounterParse = PerformanceStatistics.parse.start();
-    try {
-      RecordingErrorListener errorListener = new RecordingErrorListener();
-      for (Directive directive in _unit.directives) {
-        if (directive is ExportDirective) {
-          Source exportSource = _resolveSource(source, directive, errorListener);
-          if (exportSource != null) {
-            _exportedSources.add(exportSource);
-          }
-        } else if (directive is ImportDirective) {
-          Source importSource = _resolveSource(source, directive, errorListener);
-          if (importSource != null) {
-            _importedSources.add(importSource);
-          }
-        } else if (directive is PartDirective) {
-          Source partSource = _resolveSource(source, directive, errorListener);
-          if (partSource != null) {
-            _includedSources.add(partSource);
-          }
-        }
-      }
-      _errors = errorListener.errors;
-    } finally {
-      timeCounterParse.stop();
-    }
-  }
-
-  /**
-   * Return the result of resolving the URI of the given URI-based directive against the URI of the
-   * given library, or `null` if the URI is not valid.
-   *
-   * @param librarySource the source representing the library containing the directive
-   * @param directive the directive which URI should be resolved
-   * @param errorListener the error listener to which errors should be reported
-   * @return the result of resolving the URI against the URI of the library
-   */
-  Source _resolveSource(Source librarySource, UriBasedDirective directive, AnalysisErrorListener errorListener) {
-    StringLiteral uriLiteral = directive.uri;
-    if (uriLiteral is StringInterpolation) {
-      errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.URI_WITH_INTERPOLATION, []));
-      return null;
-    }
-    String uriContent = uriLiteral.stringValue.trim();
-    directive.uriContent = uriContent;
-    if (directive is ImportDirective && uriContent.startsWith(_DART_EXT_SCHEME)) {
-      return null;
-    }
-    try {
-      String encodedUriContent = Uri.encodeFull(uriContent);
-      parseUriWithException(encodedUriContent);
-      AnalysisContext analysisContext = context;
-      Source source = analysisContext.sourceFactory.resolveUri(librarySource, encodedUriContent);
-      if (!analysisContext.exists(source)) {
-        errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.URI_DOES_NOT_EXIST, [uriContent]));
-      }
-      directive.source = source;
-      return source;
-    } on URISyntaxException catch (exception) {
-      errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.INVALID_URI, [uriContent]));
-    }
-    return null;
-  }
-
-  /**
-   * Efficiently convert the given set of sources to an array.
-   *
-   * @param sources the set to be converted
-   * @return an array containing all of the sources in the given set
-   */
-  List<Source> _toArray(Set<Source> sources) {
-    int size = sources.length;
-    if (size == 0) {
-      return Source.EMPTY_ARRAY;
-    }
-    return new List.from(sources);
-  }
-}
-
-/**
- * Instances of the class `ResolveDartLibraryTask` parse a specific Dart library.
+ * Instances of the class `ResolveDartLibraryTask` resolve a specific Dart library.
  */
 class ResolveDartLibraryTask extends AnalysisTask {
   /**
    * The source representing the file whose compilation unit is to be returned.
    */
-  final Source unitSource;
+  Source unitSource;
 
   /**
    * The source representing the library to be resolved.
    */
-  final Source librarySource;
+  Source librarySource;
 
   /**
    * The library resolver holding information about the libraries that were resolved.
    */
   LibraryResolver _resolver;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param unitSource the source representing the file whose compilation unit is to be returned
    * @param librarySource the source representing the library to be resolved
    */
-  ResolveDartLibraryTask(InternalAnalysisContext context, this.unitSource, this.librarySource) : super(context);
+  ResolveDartLibraryTask(InternalAnalysisContext context, Source unitSource, Source librarySource) : super(context) {
+    this.unitSource = unitSource;
+    this.librarySource = librarySource;
+  }
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitResolveDartLibraryTask(this);
 
   /**
    * Return the library resolver holding information about the libraries that were resolved.
    *
    * @return the library resolver holding information about the libraries that were resolved
    */
   LibraryResolver get libraryResolver => _resolver;
@@ skipping 14 matching lines @@
 }
 
 /**
  * Instances of the class `ResolveDartUnitTask` resolve a single Dart file based on a existing
  * element model.
  */
 class ResolveDartUnitTask extends AnalysisTask {
   /**
    * The source that is to be resolved.
    */
-  final Source source;
+  Source source;
 
   /**
    * The element model for the library containing the source.
    */
   LibraryElement _libraryElement;
 
   /**
    * The time at which the contents of the source were last modified.
    */
   int _modificationTime = -1;
 
   /**
    * The compilation unit that was resolved by this task.
    */
   CompilationUnit _resolvedUnit;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be parsed
    * @param libraryElement the element model for the library containing the source
    */
-  ResolveDartUnitTask(InternalAnalysisContext context, this.source, LibraryElement libraryElement) : super(context) {
+  ResolveDartUnitTask(InternalAnalysisContext context, Source source, LibraryElement libraryElement) : super(context) {
+    this.source = source;
     this._libraryElement = libraryElement;
   }
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitResolveDartUnitTask(this);
 
   /**
    * Return the source for the library containing the source that is to be resolved.
    *
    * @return the source for the library containing the source that is to be resolved
@@ skipping 97 matching lines @@
   }
 }
 
 /**
  * Instances of the class `ResolveHtmlTask` resolve a specific source as an HTML file.
  */
 class ResolveHtmlTask extends AnalysisTask {
   /**
    * The source to be resolved.
    */
-  final Source source;
+  Source source;
 
   /**
    * The time at which the contents of the source were last modified.
    */
-  final int modificationTime;
+  int modificationTime = 0;
 
   /**
    * The HTML unit to be resolved.
    */
   ht.HtmlUnit _unit;
 
   /**
    * 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.
    */
   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 modificationTime the time at which the contents of the source were last modified
    * @param unit the HTML unit to be resolved
    */
-  ResolveHtmlTask(InternalAnalysisContext context, this.source, this.modificationTime, ht.HtmlUnit unit) : super(context) {
+  ResolveHtmlTask(InternalAnalysisContext context, Source source, int modificationTime, ht.HtmlUnit unit) : super(context) {
+    this.source = source;
+    this.modificationTime = modificationTime;
     this._unit = unit;
   }
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitResolveHtmlTask(this);
 
   HtmlElement get element => _element;
 
   List<AnalysisError> get resolutionErrors => _resolutionErrors;
 
@@ skipping 31 matching lines @@
   }
 }
 
 /**
  * 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;
+  Source source;
 
   /**
    * The time at which the contents of the source were last modified.
    */
-  final int modificationTime;
+  int modificationTime = 0;
 
   /**
    * The contents of the source.
    */
   String _content;
 
   /**
    * 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 modificationTime the time at which the contents of the source were last modified
    * @param content the contents of the source
    */
-  ScanDartTask(InternalAnalysisContext context, this.source, this.modificationTime, String content) : super(context) {
+  ScanDartTask(InternalAnalysisContext context, Source source, int modificationTime, String content) : super(context) {
+    this.source = source;
+    this.modificationTime = modificationTime;
     this._content = content;
   }
 
   @override
   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.
    *
@@ skipping 131 matching lines @@
   }
 
   @override
   void logInformation(String message) {
   }
 
   @override
   void logInformation2(String message, Exception exception) {
   }
 }