Rollback pkg/analyzer that breaks code_transformers

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 861 matching lines @@
 }
 
 /**
  * Instances of the class `AnalysisResult`
  */
 class AnalysisResult {
   /**
    * The change notices associated with this result, or `null` if there were no changes and
    * there is no more work to be done.
    */
-  final List<ChangeNotice> _notices;
+  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(this._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 219 matching lines @@
   Map<Source, SourceEntry> _sourceMap = new Map<Source, SourceEntry>();
 
   /**
    * The maximum number of sources for which AST structures should be kept in the cache.
    */
   int _maxCacheSize = 0;
 
   /**
    * The policy used to determine which pieces of data to remove from the cache.
    */
-  final CacheRetentionPolicy _retentionPolicy;
+  CacheRetentionPolicy _retentionPolicy;
 
   /**
    * A list containing the most recently accessed sources with the most recently used at the end of
    * the list. When more sources are added than the maximum allowed then the least recently used
    * source will be removed and will have it's cached AST structure flushed.
    */
   List<Source> _recentlyUsed;
 
   /**
    * Initialize a newly created cache to maintain at most the given number of AST structures in the
    * cache.
    *
    * @param maxCacheSize the maximum number of sources for which AST structures should be kept in
    *          the cache
    * @param retentionPolicy the policy used to determine which pieces of data to remove from the
    *          cache
    */
-  AnalysisCache(int maxCacheSize, this._retentionPolicy) {
+  AnalysisCache(int maxCacheSize, CacheRetentionPolicy retentionPolicy) {
     this._maxCacheSize = maxCacheSize;
+    this._retentionPolicy = retentionPolicy;
     _recentlyUsed = new List<Source>();
   }
 
   /**
    * Record that the AST associated with the given source was just read from the cache.
    *
    * @param source the source whose AST was accessed
    */
   void accessedAst(Source source) {
     if (_recentlyUsed.remove(source)) {
@@ skipping 164 matching lines @@
  * The enumeration `CacheState` defines the possible states of cached data.
  */
 class CacheState extends Enum<CacheState> {
   /**
    * The data is not in the cache and the last time an attempt was made to compute the data an
    * exception occurred, making it pointless to attempt.
    *
    * Valid Transitions:
    * * [INVALID] if a source was modified that might cause the data to be computable
    */
-  static const CacheState ERROR = const CacheState('ERROR', 0);
+  static final CacheState ERROR = new CacheState('ERROR', 0);
 
   /**
    * The data is not in the cache because it was flushed from the cache in order to control memory
    * usage. If the data is recomputed, results do not need to be reported.
    *
    * Valid Transitions:
    * * [IN_PROCESS] if the data is being recomputed
    * * [INVALID] if a source was modified that causes the data to need to be recomputed
    */
-  static const CacheState FLUSHED = const CacheState('FLUSHED', 1);
+  static final CacheState FLUSHED = new CacheState('FLUSHED', 1);
 
   /**
    * The data might or might not be in the cache but is in the process of being recomputed.
    *
    * Valid Transitions:
    * * [ERROR] if an exception occurred while trying to compute the data
    * * [VALID] if the data was successfully computed and stored in the cache
    */
-  static const CacheState IN_PROCESS = const CacheState('IN_PROCESS', 2);
+  static final CacheState IN_PROCESS = new CacheState('IN_PROCESS', 2);
 
   /**
    * The data is not in the cache and needs to be recomputed so that results can be reported.
    *
    * Valid Transitions:
    * * [IN_PROCESS] if an attempt is being made to recompute the data
    */
-  static const CacheState INVALID = const CacheState('INVALID', 3);
+  static final CacheState INVALID = new CacheState('INVALID', 3);
 
   /**
    * The data is in the cache and up-to-date.
    *
    * Valid Transitions:
    * * [FLUSHED] if the data is removed in order to manage memory usage
    * * [INVALID] if a source was modified in such a way as to invalidate the previous data
    */
-  static const CacheState VALID = const CacheState('VALID', 4);
+  static final CacheState VALID = new CacheState('VALID', 4);
 
-  static const List<CacheState> values = const [ERROR, FLUSHED, IN_PROCESS, INVALID, VALID];
+  static final List<CacheState> values = [ERROR, FLUSHED, IN_PROCESS, INVALID, VALID];
 
-  const CacheState(String name, int ordinal) : super(name, ordinal);
+  CacheState(String name, int ordinal) : super(name, ordinal);
 }
 
 /**
  * The interface `DartEntry` defines the behavior of objects that maintain the information
  * cached by an analysis context about an individual Dart file.
  */
 abstract class DartEntry implements SourceEntry {
   /**
    * The data descriptor representing the errors reported during Angular resolution.
    */
@@ skipping 297 matching lines @@
    * The state of the cached client/ server flag.
    */
   CacheState _clientServerState = CacheState.INVALID;
 
   /**
    * The state of the cached launchable flag.
    */
   CacheState _launchableState = CacheState.INVALID;
 
   /**
+   * An integer holding bit masks such as [LAUNCHABLE] and [CLIENT_CODE].
+   */
+  int _bitmask = 0;
+
+  /**
    * The error produced while performing Angular resolution, or an empty array if there are no
    * errors if the error are not currently cached.
    */
   List<AnalysisError> _angularErrors = AnalysisError.NO_ERRORS;
 
   /**
-   * The index of the flag indicating whether this library is launchable (whether the file has a
-   * main method).
+   * The index of the bit in the [bitmask] indicating that this library is launchable: that
+   * the file has a main method.
    */
   static int _LAUNCHABLE_INDEX = 1;
 
   /**
-   * The index of the flag indicating whether the library is client code (whether the library
-   * depends on the html library). If the library is not "client code", then it is referred to as
-   * "server code".
+   * The index of the bit in the [bitmask] indicating that the library is client code: that
+   * the library depends on the html library. If the library is not "client code", then it is
+   * referred to as "server code".
    */
   static int _CLIENT_CODE_INDEX = 2;
 
   /**
    * Add the given library to the list of libraries that contain this part. This method should only
    * be invoked on entries that represent a part.
    *
    * @param librarySource the source of the library to be added
    */
   void addContainingLibrary(Source librarySource) {
@@ skipping 50 matching lines @@
     while (state != null) {
       if (identical(state._resolvedUnitState, CacheState.VALID)) {
         return state._resolvedUnit;
       }
       state = state._nextState;
     }
     ;
     return null;
   }
 
-  /**
-   * Return a list containing the libraries that are known to contain this part.
-   *
-   * @return a list containing the libraries that are known to contain this part
-   */
-  List<Source> get containingLibraries => _containingLibraries;
-
   @override
   SourceKind get kind => _sourceKind;
 
   /**
    * Answer an array of library sources containing the receiver's source.
    */
   List<Source> get librariesContaining {
     DartEntryImpl_ResolutionState state = _resolutionState;
     List<Source> result = new List<Source>();
     while (state != null) {
@@ skipping 99 matching lines @@
       return new List.from(_containingLibraries);
     } else if (identical(descriptor, DartEntry.ELEMENT)) {
       return _element;
     } else if (identical(descriptor, DartEntry.EXPORTED_LIBRARIES)) {
       return _exportedLibraries;
     } else if (identical(descriptor, DartEntry.IMPORTED_LIBRARIES)) {
       return _importedLibraries;
     } else if (identical(descriptor, DartEntry.INCLUDED_PARTS)) {
       return _includedParts;
     } else if (identical(descriptor, DartEntry.IS_CLIENT)) {
-      return getFlag(_CLIENT_CODE_INDEX);
+      return BooleanArray.get(_bitmask, _CLIENT_CODE_INDEX);
     } else if (identical(descriptor, DartEntry.IS_LAUNCHABLE)) {
-      return getFlag(_LAUNCHABLE_INDEX);
+      return BooleanArray.get(_bitmask, _LAUNCHABLE_INDEX);
     } else if (identical(descriptor, DartEntry.PARSE_ERRORS)) {
       return _parseErrors;
     } else if (identical(descriptor, DartEntry.PARSED_UNIT)) {
       _parsedUnitAccessed = true;
       return _parsedUnit;
     } else if (identical(descriptor, DartEntry.PUBLIC_NAMESPACE)) {
       return _publicNamespace;
     } else if (identical(descriptor, DartEntry.SCAN_ERRORS)) {
       return _scanErrors;
     } else if (identical(descriptor, DartEntry.SOURCE_KIND)) {
@@ skipping 238 matching lines @@
   }
 
   /**
    * 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;
-    clearFlags([_LAUNCHABLE_INDEX, _CLIENT_CODE_INDEX]);
+    _bitmask = 0;
     _clientServerState = CacheState.ERROR;
     _launchableState = CacheState.ERROR;
     _publicNamespace = null;
     _publicNamespaceState = CacheState.ERROR;
     _resolutionState.recordResolutionError();
   }
 
   /**
    * Record that an in-process parse has stopped without recording results because the results were
    * invalidated before they could be recorded.
@@ skipping 119 matching lines @@
     } 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);
       _includedPartsState = state;
     } else if (identical(descriptor, DartEntry.IS_CLIENT)) {
-      _updateValueOfFlag(_CLIENT_CODE_INDEX, state);
+      _bitmask = _updatedValueOfFlag(state, _bitmask, _CLIENT_CODE_INDEX);
       _clientServerState = state;
     } else if (identical(descriptor, DartEntry.IS_LAUNCHABLE)) {
-      _updateValueOfFlag(_LAUNCHABLE_INDEX, state);
+      _bitmask = _updatedValueOfFlag(state, _bitmask, _LAUNCHABLE_INDEX);
       _launchableState = state;
     } else if (identical(descriptor, DartEntry.PARSE_ERRORS)) {
       _parseErrors = updatedValue(state, _parseErrors, AnalysisError.NO_ERRORS);
       _parseErrorsState = state;
     } else if (identical(descriptor, DartEntry.PARSED_UNIT)) {
       CompilationUnit newUnit = updatedValue(state, _parsedUnit, null);
       if (newUnit != _parsedUnit) {
         _parsedUnitAccessed = false;
       }
       _parsedUnit = newUnit;
@@ skipping 53 matching lines @@
     } else if (identical(descriptor, DartEntry.EXPORTED_LIBRARIES)) {
       _exportedLibraries = value == null ? Source.EMPTY_ARRAY : (value as List<Source>);
       _exportedLibrariesState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.IMPORTED_LIBRARIES)) {
       _importedLibraries = value == null ? Source.EMPTY_ARRAY : (value as List<Source>);
       _importedLibrariesState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.INCLUDED_PARTS)) {
       _includedParts = value == null ? Source.EMPTY_ARRAY : (value as List<Source>);
       _includedPartsState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.IS_CLIENT)) {
-      setFlag(_CLIENT_CODE_INDEX, value as bool);
+      _bitmask = BooleanArray.set(_bitmask, _CLIENT_CODE_INDEX, value as bool);
       _clientServerState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.IS_LAUNCHABLE)) {
-      setFlag(_LAUNCHABLE_INDEX, value as bool);
+      _bitmask = BooleanArray.set(_bitmask, _LAUNCHABLE_INDEX, value as bool);
       _launchableState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.PARSE_ERRORS)) {
       _parseErrors = value == null ? AnalysisError.NO_ERRORS : (value as List<AnalysisError>);
       _parseErrorsState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.PARSED_UNIT)) {
       _parsedUnit = value as CompilationUnit;
       _parsedUnitAccessed = false;
       _parsedUnitState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.PUBLIC_NAMESPACE)) {
       _publicNamespace = value as Namespace;
@@ skipping 60 matching lines @@
     _importedLibrariesState = other._importedLibrariesState;
     _importedLibraries = other._importedLibraries;
     _containingLibraries = new List<Source>.from(other._containingLibraries);
     _resolutionState.copyFrom(other._resolutionState);
     _elementState = other._elementState;
     _element = other._element;
     _publicNamespaceState = other._publicNamespaceState;
     _publicNamespace = other._publicNamespace;
     _clientServerState = other._clientServerState;
     _launchableState = other._launchableState;
+    _bitmask = other._bitmask;
     _angularErrors = other._angularErrors;
   }
 
   @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(_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);
@@ skipping 26 matching lines @@
     //    builder.append("; angularElements = ");
     _resolutionState.writeOn(builder);
   }
 
   /**
    * Invalidate all of the resolution information associated with the compilation unit.
    */
   void _discardCachedResolutionInformation() {
     _element = null;
     _elementState = CacheState.INVALID;
-    clearFlags([_LAUNCHABLE_INDEX, _CLIENT_CODE_INDEX]);
+    _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 12 matching lines @@
         newState._librarySource = librarySource;
         state._nextState = newState;
         return newState;
       }
       state = state._nextState;
     }
     return state;
   }
 
   /**
-   * Given that the specified flag is being transitioned to the given state, set the value of the
-   * flag to the value that should be kept in the cache.
+   * Given that one of the flags is being transitioned to the given state, return the value of the
+   * flags that should be kept in the cache.
    *
-   * @param index the index of the flag whose state is being set
-   * @param state the state to which the value is being transitioned
+   * @param state the state to which the data is being transitioned
+   * @param currentValue the value of the flags before the transition
+   * @param bitMask the mask used to access the bit whose state is being set
+   * @return the value of the data that should be kept in the cache
    */
-  void _updateValueOfFlag(int index, CacheState state) {
+  int _updatedValueOfFlag(CacheState state, int currentValue, int bitIndex) {
     if (identical(state, CacheState.VALID)) {
       throw new IllegalArgumentException("Use setValue() to set the state to VALID");
-    } else if (state != CacheState.IN_PROCESS) {
+    } else if (identical(state, CacheState.IN_PROCESS)) {
       //
-      // If the value is in process, we can leave the current value in the cache for any 'get'
-      // methods to access.
+      // We can leave the current value in the cache for any 'get' methods to access.
       //
-      setFlag(index, false);
+      return currentValue;
     }
+    return BooleanArray.set(currentValue, bitIndex, false);
   }
 }
 
 /**
  * Instances of the class `ResolutionState` represent the information produced by resolving
  * a compilation unit as part of a specific library.
  */
 class DartEntryImpl_ResolutionState {
   /**
    * The next resolution state or `null` if none.
@@ skipping 169 matching lines @@
 }
 
 /**
  * Instances of the class `DataDescriptor` are immutable constants representing data that can
  * be stored in the cache.
  */
 class DataDescriptor<E> {
   /**
    * The name of the descriptor, used for debugging purposes.
    */
-  final String _name;
+  String _name;
 
   /**
    * Initialize a newly created descriptor to have the given name.
    *
    * @param name the name of the descriptor
    */
-  DataDescriptor(this._name);
+  DataDescriptor(String name) {
+    this._name = name;
+  }
 
   @override
   String toString() => _name;
 }
 
 /**
  * The interface `HtmlEntry` defines the behavior of objects that maintain the information
  * cached by an analysis context about an individual HTML file.
  */
 abstract class HtmlEntry implements SourceEntry {
@@ skipping 521 matching lines @@
 
 /**
  * The enumerated type `RetentionPriority` represents the priority of data in the cache in
  * terms of the desirability of retaining some specified data about a specified source.
  */
 class RetentionPriority extends Enum<RetentionPriority> {
   /**
    * A priority indicating that a given piece of data can be removed from the cache without
    * reservation.
    */
-  static const RetentionPriority LOW = const RetentionPriority('LOW', 0);
+  static final RetentionPriority LOW = new RetentionPriority('LOW', 0);
 
   /**
    * A priority indicating that a given piece of data should not be removed from the cache unless
    * there are no sources for which the corresponding data has a lower priority. Currently used for
    * data that is needed in order to finish some outstanding analysis task.
    */
-  static const RetentionPriority MEDIUM = const RetentionPriority('MEDIUM', 1);
+  static final RetentionPriority MEDIUM = new RetentionPriority('MEDIUM', 1);
 
   /**
    * A priority indicating that a given piece of data should not be removed from the cache.
    * Currently used for data related to a priority source.
    */
-  static const RetentionPriority HIGH = const RetentionPriority('HIGH', 2);
+  static final RetentionPriority HIGH = new RetentionPriority('HIGH', 2);
 
-  static const List<RetentionPriority> values = const [LOW, MEDIUM, HIGH];
+  static final List<RetentionPriority> values = [LOW, MEDIUM, HIGH];
 
-  const RetentionPriority(String name, int ordinal) : super(name, ordinal);
+  RetentionPriority(String name, int ordinal) : super(name, ordinal);
 }
 
 /**
  * The interface `SourceEntry` defines the behavior of objects that maintain the information
  * cached by an analysis context about an individual source, no matter what kind of source it is.
  *
  * Source entries should be treated as if they were immutable unless a writable copy of the entry
  * has been obtained and has not yet been made visible to other threads.
  */
 abstract class SourceEntry {
   /**
    * The data descriptor representing the contents of the source.
    */
   static final DataDescriptor<String> CONTENT = new DataDescriptor<String>("DartEntry.CONTENT");
 
   /**
    * The data descriptor representing the line information.
    */
   static final DataDescriptor<LineInfo> LINE_INFO = new DataDescriptor<LineInfo>("SourceEntry.LINE_INFO");
 
   /**
    * Return the exception that caused one or more values to have a state of [CacheState#ERROR]
    * .
    *
    * @return the exception that caused one or more values to be uncomputable
    */
   AnalysisException get exception;
 
   /**
-   * Return `true` if the source was explicitly added to the context or `false` if the
-   * source was implicitly added because it was referenced by another source.
-   *
-   * @return `true` if the source was explicitly added to the context
-   */
-  bool get explicitlyAdded;
-
-  /**
    * Return the kind of the source, or `null` if the kind is not currently cached.
    *
    * @return the kind of the source
    */
   SourceKind get kind;
 
   /**
    * Return the most recent time at which the state of the source matched the state represented by
    * this entry.
    *
@@ skipping 32 matching lines @@
  * [SourceEntry].
  */
 abstract class SourceEntryImpl implements SourceEntry {
   /**
    * The most recent time at which the state of the source matched the state represented by this
    * entry.
    */
   int _modificationTime = 0;
 
   /**
-   * A bit-encoding of boolean flags associated with this element.
-   */
-  int _flags = 0;
-
-  /**
    * The exception that caused one or more values to have a state of [CacheState#ERROR].
    */
   AnalysisException exception;
 
   /**
    * The state of the cached content.
    */
   CacheState _contentState = CacheState.INVALID;
 
   /**
    * The content of the source, or `null` if the content is not currently cached.
    */
   String _content;
 
   /**
    * The state of the cached line information.
    */
   CacheState _lineInfoState = CacheState.INVALID;
 
   /**
    * The line information computed for the source, or `null` if the line information is not
    * currently cached.
    */
   LineInfo _lineInfo;
 
   /**
-   * The index of the flag indicating whether the source was explicitly added to the context or
-   * whether the source was implicitly added because it was referenced by another source.
-   */
-  static int _EXPLICITLY_ADDED_FLAG = 0;
-
-  /**
    * Fix the state of the [exception] to match the current state of the entry.
    */
   void fixExceptionState() {
     if (hasErrorState) {
       if (exception == null) {
         //
         // This code should never be reached, but is a fail-safe in case an exception is not
         // recorded when it should be.
         //
         exception = new AnalysisException.con1("State set to ERROR without setting an exception");
       }
     } else {
       exception = null;
     }
   }
 
-  /**
-   * Return `true` if the source was explicitly added to the context or `false` if the
-   * source was implicitly added because it was referenced by another source.
-   *
-   * @return `true` if the source was explicitly added to the context
-   */
-  @override
-  bool get explicitlyAdded => getFlag(_EXPLICITLY_ADDED_FLAG);
-
   @override
   int get modificationTime => _modificationTime;
 
   @override
   CacheState getState(DataDescriptor descriptor) {
     if (identical(descriptor, SourceEntry.CONTENT)) {
       return _contentState;
     } else if (identical(descriptor, SourceEntry.LINE_INFO)) {
       return _lineInfoState;
     } else {
@@ skipping 26 matching lines @@
    * Record that an error occurred while attempting to get the contents of the source represented by
    * this entry. This will set the state of all information, including any resolution-based
    * information, as being in error.
    */
   void recordContentError() {
     _content = null;
     _contentState = CacheState.ERROR;
   }
 
   /**
-   * Set whether the source was explicitly added to the context to match the given value.
-   *
-   * @param explicitlyAdded `true` if the source was explicitly added to the context
-   */
-  void set explicitlyAdded(bool explicitlyAdded) {
-    setFlag(_EXPLICITLY_ADDED_FLAG, explicitlyAdded);
-  }
-
-  /**
    * Set the most recent time at which the state of the source matched the state represented by this
    * entry to the given time.
    *
    * @param time the new modification time of this entry
    */
   void set modificationTime(int time) {
     _modificationTime = time;
   }
 
   /**
@@ skipping 33 matching lines @@
   }
 
   @override
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
     writeOn(builder);
     return builder.toString();
   }
 
   /**
-   * Set the value of all of the flags with the given indexes to false.
-   *
-   * @param indexes the indexes of the flags whose value is to be set to false
-   */
-  void clearFlags(List<int> indexes) {
-    for (int i = 0; i < indexes.length; i++) {
-      _flags = BooleanArray.set(_flags, indexes[i], false);
-    }
-  }
-
-  /**
    * Copy the information from the given cache entry.
    *
    * @param entry the cache entry from which information will be copied
    */
   void copyFrom(SourceEntryImpl entry) {
     _modificationTime = entry._modificationTime;
-    _flags = entry._flags;
     exception = entry.exception;
     _contentState = entry._contentState;
     _content = entry._content;
     _lineInfoState = entry._lineInfoState;
     _lineInfo = entry._lineInfo;
   }
 
   /**
-   * Return the value of the flag with the given index.
-   *
-   * @param index the index of the flag whose value is to be returned
-   * @return the value of the flag with the given index
-   */
-  bool getFlag(int index) => BooleanArray.get(_flags, index);
-
-  /**
    * Return `true` if the state of any data value is [CacheState#ERROR].
    *
    * @return `true` if the state of any data value is [CacheState#ERROR]
    */
   bool get hasErrorState => identical(_contentState, CacheState.ERROR) || identical(_lineInfoState, CacheState.ERROR);
 
   /**
-   * Set the value of the flag with the given index to the given value.
-   *
-   * @param index the index of the flag whose value is to be returned
-   * @param value the value of the flag with the given index
-   */
-  void setFlag(int index, bool value) {
-    _flags = BooleanArray.set(_flags, index, value);
-  }
-
-  /**
    * Given that some data is being transitioned to the given state, return the value that should be
    * kept in the cache.
    *
    * @param state the state to which the data is being transitioned
    * @param currentValue the value of the data before the transition
    * @param defaultValue the value to be used if the current value is to be removed from the cache
    * @return the value of the data that should be kept in the cache
    */
   Object updatedValue(CacheState state, Object currentValue, Object defaultValue) {
     if (identical(state, CacheState.VALID)) {
@@ skipping 68 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 1084 matching lines @@
               _cache.remove(source);
             }
             dartCopy.exception = thrownException;
             _cache.put(source, dartCopy);
             if (source != librarySource) {
               _workManager.add(source, SourcePriority.PRIORITY_PART);
             }
             if (source == unitSource) {
               unitEntry = dartCopy;
             }
-            ChangeNoticeImpl notice = _getNotice(source);
-            notice.compilationUnit = unit;
-            notice.setErrors(dartCopy.allErrors, lineInfo);
+            if (_generateSdkErrors || !source.isInSystemLibrary) {
+              ChangeNoticeImpl notice = _getNotice(source);
+              notice.compilationUnit = unit;
+              notice.setErrors(dartCopy.allErrors, lineInfo);
+            }
           }
         }
       } else {
         PrintStringWriter writer = new PrintStringWriter();
         writer.println("Library resolution results discarded for");
         for (ResolvableLibrary library in resolvedLibraries) {
           for (Source source in library.compilationUnitSources) {
             DartEntry dartEntry = _getReadableDartEntry(source);
             if (dartEntry != null) {
               int resultTime = library.getModificationTime(source);
@@ skipping 102 matching lines @@
               _cache.remove(source);
             }
             dartCopy.exception = thrownException;
             _cache.put(source, dartCopy);
             if (source != librarySource) {
               _workManager.add(source, SourcePriority.PRIORITY_PART);
             }
             if (source == unitSource) {
               unitEntry = dartCopy;
             }
-            ChangeNoticeImpl notice = _getNotice(source);
-            notice.compilationUnit = unit;
-            notice.setErrors(dartCopy.allErrors, lineInfo);
+            if (_generateSdkErrors || !source.isInSystemLibrary) {
+              ChangeNoticeImpl notice = _getNotice(source);
+              notice.compilationUnit = unit;
+              notice.setErrors(dartCopy.allErrors, lineInfo);
+            }
           }
         }
       } else {
         PrintStringWriter writer = new PrintStringWriter();
         writer.println("Library resolution results discarded for");
         for (Library library in resolvedLibraries) {
           for (Source source in library.compilationUnitSources) {
             DartEntry dartEntry = _getReadableDartEntry(source);
             if (dartEntry != null) {
               int resultTime = library.getModificationTime(source);
@@ skipping 429 matching lines @@
     for (Source targetSource in targetSources) {
       if (_contains(sources, targetSource)) {
         return true;
       }
     }
     return false;
   }
 
   /**
    * Create a [GenerateDartErrorsTask] for the given source, marking the verification errors
-   * as being in-process. The compilation unit and the library can be the same if the compilation
-   * unit is the defining compilation unit of the library.
+   * as being in-process.
    *
-   * @param unitSource the source for the compilation unit to be verified
-   * @param unitEntry the entry for the compilation unit
-   * @param librarySource the source for the library containing the compilation unit
+   * @param source the source whose content is to be verified
+   * @param dartEntry the entry for the source
+   * @param librarySource the source for the library containing the source
    * @param libraryEntry the entry for the library
    * @return task data representing the created task
    */
-  AnalysisContextImpl_TaskData _createGenerateDartErrorsTask(Source unitSource, DartEntry unitEntry, Source librarySource, DartEntry libraryEntry) {
-    if (unitEntry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource) != CacheState.VALID || libraryEntry.getState(DartEntry.ELEMENT) != CacheState.VALID) {
-      return _createResolveDartLibraryTask(librarySource, libraryEntry);
+  AnalysisContextImpl_TaskData _createGenerateDartErrorsTask(Source source, DartEntry dartEntry, Source librarySource, SourceEntry libraryEntry) {
+    if (dartEntry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource) != CacheState.VALID || libraryEntry.getState(DartEntry.ELEMENT) != CacheState.VALID) {
     }
-    CompilationUnit unit = unitEntry.getValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource);
+    CompilationUnit unit = dartEntry.getValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource);
     LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
-    DartEntryImpl dartCopy = unitEntry.writableCopy;
+    DartEntryImpl dartCopy = dartEntry.writableCopy;
     dartCopy.setStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.IN_PROCESS);
-    _cache.put(unitSource, dartCopy);
-    return new AnalysisContextImpl_TaskData(new GenerateDartErrorsTask(this, unitSource, dartCopy.modificationTime, unit, libraryElement), false);
+    _cache.put(source, dartCopy);
+    return new AnalysisContextImpl_TaskData(new GenerateDartErrorsTask(this, source, dartCopy.modificationTime, unit, libraryElement), false);
   }
 
   /**
    * Create a [GenerateDartHintsTask] for the given source, marking the hints as being
    * in-process.
    *
    * @param source the source whose content is to be verified
    * @param dartEntry the entry for the source
    * @param librarySource the source for the library containing the source
    * @param libraryEntry the entry for the library
@@ skipping 178 matching lines @@
     dartCopy.setState(DartEntry.SCAN_ERRORS, CacheState.IN_PROCESS);
     _cache.put(source, dartCopy);
     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
-   * @param explicitlyAdded `true` if the source was explicitly added to the context
    * @return the source information object that was created
    */
-  SourceEntry _createSourceEntry(Source source, bool explicitlyAdded) {
+  SourceEntry _createSourceEntry(Source source) {
     String name = source.shortName;
     if (AnalysisEngine.isHtmlFileName(name)) {
       HtmlEntryImpl htmlEntry = new HtmlEntryImpl();
       htmlEntry.modificationTime = getModificationStamp(source);
-      htmlEntry.explicitlyAdded = explicitlyAdded;
       _cache.put(source, htmlEntry);
       return htmlEntry;
     } else {
       DartEntryImpl dartEntry = new DartEntryImpl();
       dartEntry.modificationTime = getModificationStamp(source);
-      dartEntry.explicitlyAdded = explicitlyAdded;
       _cache.put(source, dartEntry);
       return dartEntry;
     }
   }
 
   /**
    * Return a string with debugging information about the given source (the full name and
    * modification stamp of the source).
    *
    * @param source the source for which a debugging string is to be produced
@@ skipping 435 matching lines @@
       if (identical(kind, SourceKind.UNKNOWN)) {
         return _createParseDartTask(source, dartEntry);
       } else if (identical(kind, SourceKind.LIBRARY)) {
         CacheState elementState = dartEntry.getState(DartEntry.ELEMENT);
         if (identical(elementState, CacheState.INVALID)) {
           return _createResolveDartLibraryTask(source, dartEntry);
         }
       }
       List<Source> librariesContaining = dartEntry.getValue(DartEntry.CONTAINING_LIBRARIES);
       for (Source librarySource in librariesContaining) {
-        SourceEntry librarySourceEntry = _cache.get(librarySource);
-        if (librarySourceEntry is DartEntry) {
-          DartEntry libraryEntry = librarySourceEntry;
+        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))) {
             //return createResolveDartLibraryTask(librarySource, (DartEntry) libraryEntry);
             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);
           }
           CacheState resolvedUnitState = dartEntry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource);
           if (identical(resolvedUnitState, CacheState.INVALID) || (isPriority && identical(resolvedUnitState, CacheState.FLUSHED))) {
@@ skipping 79 matching lines @@
   /**
    * Return the cache entry associated with the given source, or `null` if the source is not a
    * Dart file.
    *
    * @param source the source for which a cache entry is being sought
    * @return the source cache entry associated with the given source
    */
   DartEntry _getReadableDartEntry(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
-      sourceEntry = _createSourceEntry(source, false);
+      sourceEntry = _createSourceEntry(source);
     }
     if (sourceEntry is DartEntry) {
       return sourceEntry as DartEntry;
     }
     return null;
   }
 
   /**
    * Return the cache entry associated with the given source, or `null` if the source is not
    * an HTML file.
    *
    * @param source the source for which a cache entry is being sought
    * @return the source cache entry associated with the given source
    */
   HtmlEntry _getReadableHtmlEntry(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
-      sourceEntry = _createSourceEntry(source, false);
+      sourceEntry = _createSourceEntry(source);
     }
     if (sourceEntry is HtmlEntry) {
       return sourceEntry as HtmlEntry;
     }
     return null;
   }
 
   /**
    * Return the cache entry associated with the given source, creating it if necessary.
    *
    * @param source the source for which a cache entry is being sought
    * @return the source cache entry associated with the given source
    */
   SourceEntry _getReadableSourceEntry(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
-      sourceEntry = _createSourceEntry(source, false);
+      sourceEntry = _createSourceEntry(source);
     }
     return sourceEntry;
   }
 
   /**
    * Return the cache entry associated with the given source, or `null` if there is no entry
    * associated with the source.
    *
    * @param source the source for which a cache entry is being sought
    * @return the source cache entry associated with the given source
@@ skipping 138 matching lines @@
       }
     }
   }
 
   /**
    * Invalidate all of the resolution results computed by this context.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    */
   void _invalidateAllResolutionInformation() {
-    Map<Source, List<Source>> oldPartMap = new Map<Source, List<Source>>();
     for (MapEntry<Source, SourceEntry> mapEntry in _cache.entrySet()) {
       Source source = mapEntry.getKey();
       SourceEntry sourceEntry = mapEntry.getValue();
       if (sourceEntry is HtmlEntry) {
         HtmlEntryImpl htmlCopy = sourceEntry.writableCopy;
         htmlCopy.invalidateAllResolutionInformation();
         mapEntry.setValue(htmlCopy);
       } else if (sourceEntry is DartEntry) {
         DartEntry dartEntry = sourceEntry;
-        oldPartMap[source] = dartEntry.getValue(DartEntry.INCLUDED_PARTS);
+        _removeFromParts(source, dartEntry);
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         dartCopy.invalidateAllResolutionInformation();
         mapEntry.setValue(dartCopy);
         _workManager.add(source, SourcePriority.UNKNOWN);
       }
     }
-    _removeFromPartsUsingMap(oldPartMap);
   }
 
   /**
    * In response to a change to Angular entry point [HtmlElement], invalidate any results that
    * depend on it.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * <b>Note:</b> Any cache entries that were accessed before this method was invoked must be
    * re-accessed after this method returns.
@@ skipping 26 matching lines @@
       }
     }
     // reset Dart sources
     List<Source> oldElementSources = application.elementSources;
     for (Source elementSource in oldElementSources) {
       DartEntry dartEntry = _getReadableDartEntry(elementSource);
       DartEntryImpl dartCopy = dartEntry.writableCopy;
       dartCopy.setValue(DartEntry.ANGULAR_ERRORS, AnalysisError.NO_ERRORS);
       _cache.put(elementSource, dartCopy);
       // notify about (disappeared) Angular errors
-      ChangeNoticeImpl notice = _getNotice(elementSource);
-      notice.setErrors(dartCopy.allErrors, dartEntry.getValue(SourceEntry.LINE_INFO));
+      if (_generateSdkErrors || !elementSource.isInSystemLibrary) {
+        ChangeNoticeImpl notice = _getNotice(elementSource);
+        notice.setErrors(dartCopy.allErrors, dartEntry.getValue(SourceEntry.LINE_INFO));
+      }
     }
   }
 
   /**
    * In response to a change to at least one of the compilation units in the given library,
    * invalidate any results that are dependent on the result of resolving that library.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * <b>Note:</b> Any cache entries that were accessed before this method was invoked must be
    * re-accessed after this method returns.
    *
    * @param librarySource the source of the library being invalidated
+   * @param writer the writer to which debugging information should be written
    */
-  void _invalidateLibraryResolution(Source librarySource) {
-    // TODO(brianwilkerson) This could be optimized. There's no need to flush all of these entries
-    // if the public namespace hasn't changed, which will be a fairly common case. The question is
+  void _invalidateLibraryResolution(Source librarySource, PrintStringWriter writer) {
+    // TODO(brianwilkerson) This could be optimized. There's no need to flush all of these caches if
+    // the public namespace hasn't changed, which will be a fairly common case. The question is
     // whether we can afford the time to compute the namespace to look for differences.
     DartEntry libraryEntry = _getReadableDartEntry(librarySource);
     if (libraryEntry != null) {
       List<Source> includedParts = libraryEntry.getValue(DartEntry.INCLUDED_PARTS);
       DartEntryImpl libraryCopy = libraryEntry.writableCopy;
+      //      long oldTime = libraryCopy.getModificationTime();
       libraryCopy.invalidateAllResolutionInformation();
       _cache.put(librarySource, libraryCopy);
       _workManager.add(librarySource, SourcePriority.LIBRARY);
+      //      if (writer != null) {
+      //        writer.println("  Invalidated library source: " + debuggingString(librarySource)
+      //            + " (previously modified at " + oldTime + ")");
+      //      }
       for (Source partSource in includedParts) {
         SourceEntry partEntry = _cache.get(partSource);
         if (partEntry is DartEntry) {
           DartEntryImpl partCopy = partEntry.writableCopy;
+          //          oldTime = partCopy.getModificationTime();
+          if (partEntry != libraryCopy) {
+            partCopy.removeContainingLibrary(librarySource);
+            _workManager.add(librarySource, SourcePriority.NORMAL_PART);
+          }
           partCopy.invalidateAllResolutionInformation();
           _cache.put(partSource, partCopy);
         }
       }
     }
     // invalidate Angular applications
     List<AngularApplication> angularApplicationsCopy = [];
     for (AngularApplication application in angularApplicationsCopy) {
       if (application.dependsOn(librarySource)) {
         Source entryPointSource = application.entryPoint;
@@ skipping 89 matching lines @@
         }
       }
       // update Dart sources errors
       List<Source> newElementSources = application.elementSources;
       for (Source elementSource in newElementSources) {
         DartEntry dartEntry = _getReadableDartEntry(elementSource);
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         dartCopy.setValue(DartEntry.ANGULAR_ERRORS, task.getErrors(elementSource));
         _cache.put(elementSource, dartCopy);
         // notify about Dart errors
-        ChangeNoticeImpl notice = _getNotice(elementSource);
-        notice.setErrors(dartCopy.allErrors, computeLineInfo(elementSource));
+        if (_generateSdkErrors || !elementSource.isInSystemLibrary) {
+          ChangeNoticeImpl notice = _getNotice(elementSource);
+          notice.setErrors(dartCopy.allErrors, computeLineInfo(elementSource));
+        }
       }
     }
     // remember Angular entry point
     entry.setValue(HtmlEntry.ANGULAR_ENTRY, application);
   }
 
   /**
    * Given a cache entry and a library element, record the library element and other information
    * gleaned from the element in the cache entry.
    *
@@ skipping 38 matching lines @@
         // The source has changed without the context being notified. Simulate notification.
         _sourceChanged(source);
         dartEntry = _getReadableDartEntry(source);
         if (dartEntry == null) {
           throw new AnalysisException.con1("A Dart file became a non-Dart file: ${source.fullName}");
         }
       }
       DartEntryImpl dartCopy = dartEntry.writableCopy;
       if (thrownException == null) {
         dartCopy.setValueInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource, task.errors);
-        ChangeNoticeImpl notice = _getNotice(source);
-        notice.setErrors(dartCopy.allErrors, dartCopy.getValue(SourceEntry.LINE_INFO));
+        if (_generateSdkErrors || !source.isInSystemLibrary) {
+          ChangeNoticeImpl notice = _getNotice(source);
+          notice.setErrors(dartCopy.allErrors, dartCopy.getValue(SourceEntry.LINE_INFO));
+        }
       } else {
         dartCopy.setStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.ERROR);
       }
       dartCopy.exception = thrownException;
       _cache.put(source, dartCopy);
       dartEntry = dartCopy;
     } else {
       _logInformation2("Generated errors discarded for ${_debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
       DartEntryImpl dartCopy = dartEntry.writableCopy;
       if (thrownException == null || resultTime >= 0) {
@@ skipping 78 matching lines @@
           // The source has changed without the context being notified. Simulate notification.
           _sourceChanged(unitSource);
           dartEntry = _getReadableDartEntry(unitSource);
           if (dartEntry == null) {
             throw new AnalysisException.con1("A Dart file became a non-Dart file: ${unitSource.fullName}");
           }
         }
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         if (thrownException == null) {
           dartCopy.setValueInLibrary(DartEntry.HINTS, librarySource, results.data);
-          ChangeNoticeImpl notice = _getNotice(unitSource);
-          notice.setErrors(dartCopy.allErrors, dartCopy.getValue(SourceEntry.LINE_INFO));
+          if (_generateSdkErrors || !unitSource.isInSystemLibrary) {
+            ChangeNoticeImpl notice = _getNotice(unitSource);
+            notice.setErrors(dartCopy.allErrors, dartCopy.getValue(SourceEntry.LINE_INFO));
+          }
         } else {
           dartCopy.setStateInLibrary(DartEntry.HINTS, librarySource, CacheState.ERROR);
         }
         dartCopy.exception = thrownException;
         _cache.put(unitSource, dartCopy);
         dartEntry = dartCopy;
       } else {
         _logInformation2("Generated hints discarded for ${_debuggingString(unitSource)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
         if (identical(dartEntry.getStateInLibrary(DartEntry.HINTS, librarySource), CacheState.IN_PROCESS)) {
           DartEntryImpl dartCopy = dartEntry.writableCopy;
@@ skipping 66 matching lines @@
   /**
    * Record the results produced by performing a [IncrementalAnalysisTask].
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   DartEntry _recordIncrementalAnalysisTaskResults(IncrementalAnalysisTask task) {
     CompilationUnit unit = task.compilationUnit;
     if (unit != null) {
-      ChangeNoticeImpl notice = _getNotice(task.source);
-      notice.compilationUnit = unit;
+      if (_generateSdkErrors || !task.source.isInSystemLibrary) {
+        ChangeNoticeImpl notice = _getNotice(task.source);
+        notice.compilationUnit = unit;
+      }
       _incrementalAnalysisCache = IncrementalAnalysisCache.cacheResult(task.cache, unit);
     }
     return null;
   }
 
   /**
    * Record the results produced by performing a [ParseDartTask]. 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
@@ skipping 20 matching lines @@
         // 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.hasNonPartOfDirective) {
-          dartCopy.setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY);
-          dartCopy.containingLibrary = source;
-          _workManager.add(source, SourcePriority.LIBRARY);
-        } else if (task.hasPartOfDirective) {
+        if (task.hasPartOfDirective && !task.hasLibraryDirective) {
           dartCopy.setValue(DartEntry.SOURCE_KIND, SourceKind.PART);
           dartCopy.removeContainingLibrary(source);
           _workManager.add(source, SourcePriority.NORMAL_PART);
         } else {
-          // The file contains no directives.
-          List<Source> containingLibraries = dartCopy.containingLibraries;
-          if (containingLibraries.length > 1 || (containingLibraries.length == 1 && containingLibraries[0] != source)) {
-            dartCopy.setValue(DartEntry.SOURCE_KIND, SourceKind.PART);
-            dartCopy.removeContainingLibrary(source);
-            _workManager.add(source, SourcePriority.NORMAL_PART);
-          } else {
-            dartCopy.setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY);
-            dartCopy.containingLibrary = source;
-            _workManager.add(source, SourcePriority.LIBRARY);
-          }
+          dartCopy.setValue(DartEntry.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;
-            // TODO(brianwilkerson) Change the kind of the "part" if it was marked as a library
-            // and it has no directives.
             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, task.lineInfo);
+        if (_generateSdkErrors || !source.isInSystemLibrary) {
+          ChangeNoticeImpl notice = _getNotice(source);
+          notice.setErrors(dartCopy.allErrors, task.lineInfo);
+        }
         // Verify that the incrementally parsed and resolved unit in the incremental cache
         // is structurally equivalent to the fully parsed unit
         _incrementalAnalysisCache = IncrementalAnalysisCache.verifyStructure(_incrementalAnalysisCache, source, task.compilationUnit);
       } else {
         _removeFromParts(source, dartEntry);
         dartCopy.recordParseError();
         _cache.removedAst(source);
       }
       dartCopy.exception = thrownException;
       _cache.put(source, dartCopy);
@@ skipping 64 matching lines @@
       }
       HtmlEntryImpl htmlCopy = (sourceEntry as HtmlEntry).writableCopy;
       if (thrownException == null) {
         LineInfo lineInfo = task.lineInfo;
         ht.HtmlUnit unit = task.htmlUnit;
         htmlCopy.setValue(SourceEntry.LINE_INFO, lineInfo);
         htmlCopy.setValue(HtmlEntry.PARSED_UNIT, unit);
         htmlCopy.setValue(HtmlEntry.PARSE_ERRORS, task.errors);
         htmlCopy.setValue(HtmlEntry.REFERENCED_LIBRARIES, task.referencedLibraries);
         _cache.storedAst(source);
-        ChangeNoticeImpl notice = _getNotice(source);
-        notice.setErrors(htmlCopy.allErrors, lineInfo);
+        if (_generateSdkErrors || !source.isInSystemLibrary) {
+          ChangeNoticeImpl notice = _getNotice(source);
+          notice.setErrors(htmlCopy.allErrors, lineInfo);
+        }
       } else {
         htmlCopy.recordParseError();
         _cache.removedAst(source);
       }
       htmlCopy.exception = thrownException;
       _cache.put(source, htmlCopy);
       htmlEntry = htmlCopy;
     } else {
       _logInformation2("Parse results discarded for ${_debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${htmlEntry.modificationTime}", thrownException);
       HtmlEntryImpl htmlCopy = (sourceEntry as HtmlEntry).writableCopy;
@@ skipping 63 matching lines @@
         _sourceChanged(source);
         htmlEntry = _getReadableHtmlEntry(source);
         if (htmlEntry == null) {
           throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
         }
       }
       HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
       if (thrownException == null) {
         htmlCopy.setValue(HtmlEntry.ANGULAR_ERRORS, task.resolutionErrors);
         // notify about errors
-        ChangeNoticeImpl notice = _getNotice(source);
-        notice.htmlUnit = task.resolvedUnit;
-        notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
+        if (_generateSdkErrors || !source.isInSystemLibrary) {
+          ChangeNoticeImpl notice = _getNotice(source);
+          notice.htmlUnit = task.resolvedUnit;
+          notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
+        }
       } else {
         htmlCopy.recordResolutionError();
       }
       htmlCopy.exception = thrownException;
       _cache.put(source, htmlCopy);
       htmlEntry = htmlCopy;
     } else {
       HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
       if (thrownException == null || resultTime >= 0) {
         //
@@ skipping 59 matching lines @@
         htmlEntry = _getReadableHtmlEntry(source);
         if (htmlEntry == null) {
           throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
         }
       }
       HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
       if (thrownException == null) {
         htmlCopy.setValue(HtmlEntry.RESOLVED_UNIT, task.resolvedUnit);
         _recordAngularEntryPoint(htmlCopy, task);
         _cache.storedAst(source);
-        ChangeNoticeImpl notice = _getNotice(source);
-        notice.htmlUnit = task.resolvedUnit;
-        notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
+        if (_generateSdkErrors || !source.isInSystemLibrary) {
+          ChangeNoticeImpl notice = _getNotice(source);
+          notice.htmlUnit = task.resolvedUnit;
+          notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
+        }
       } else {
         htmlCopy.recordResolutionError();
       }
       htmlCopy.exception = thrownException;
       _cache.put(source, htmlCopy);
       htmlEntry = htmlCopy;
     } else {
       HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
       if (thrownException == null || resultTime >= 0) {
         //
@@ skipping 140 matching lines @@
           throw new AnalysisException.con1("An HTML file became a non-HTML file: ${source.fullName}");
         }
       }
       HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
       if (thrownException == null) {
         htmlCopy.setState(HtmlEntry.PARSED_UNIT, CacheState.FLUSHED);
         htmlCopy.setValue(HtmlEntry.RESOLVED_UNIT, task.resolvedUnit);
         htmlCopy.setValue(HtmlEntry.ELEMENT, task.element);
         htmlCopy.setValue(HtmlEntry.RESOLUTION_ERRORS, task.resolutionErrors);
         _cache.storedAst(source);
-        ChangeNoticeImpl notice = _getNotice(source);
-        notice.htmlUnit = task.resolvedUnit;
-        notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
+        if (_generateSdkErrors || !source.isInSystemLibrary) {
+          ChangeNoticeImpl notice = _getNotice(source);
+          notice.htmlUnit = task.resolvedUnit;
+          notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
+        }
       } else {
         htmlCopy.recordResolutionError();
         _cache.removedAst(source);
       }
       htmlCopy.exception = thrownException;
       _cache.put(source, htmlCopy);
       htmlEntry = htmlCopy;
     } else {
       _logInformation2("Resolution results discarded for ${_debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${htmlEntry.modificationTime}", thrownException);
       HtmlEntryImpl htmlCopy = htmlEntry.writableCopy;
@@ skipping 62 matching lines @@
         }
       }
       DartEntryImpl dartCopy = dartEntry.writableCopy;
       if (thrownException == null) {
         LineInfo lineInfo = task.lineInfo;
         dartCopy.setValue(SourceEntry.LINE_INFO, lineInfo);
         dartCopy.setValue(DartEntry.TOKEN_STREAM, task.tokenStream);
         dartCopy.setValue(DartEntry.SCAN_ERRORS, task.errors);
         _cache.storedAst(source);
         _workManager.add(source, SourcePriority.NORMAL_PART);
-        ChangeNoticeImpl notice = _getNotice(source);
-        notice.setErrors(dartEntry.allErrors, lineInfo);
+        if (_generateSdkErrors || !source.isInSystemLibrary) {
+          ChangeNoticeImpl notice = _getNotice(source);
+          notice.setErrors(dartEntry.allErrors, lineInfo);
+        }
       } else {
         _removeFromParts(source, dartEntry);
         dartCopy.recordScanError();
         _cache.removedAst(source);
       }
       dartCopy.exception = thrownException;
       _cache.put(source, dartCopy);
       dartEntry = dartCopy;
     } else {
       _logInformation2("Scan results discarded for ${_debuggingString(source)}; sourceTime = ${sourceTime}, resultTime = ${resultTime}, cacheTime = ${dartEntry.modificationTime}", thrownException);
@@ skipping 37 matching lines @@
    * @param dartEntry the entry containing the list of included parts
    */
   void _removeFromParts(Source librarySource, DartEntry dartEntry) {
     List<Source> oldParts = dartEntry.getValue(DartEntry.INCLUDED_PARTS);
     for (int i = 0; i < oldParts.length; i++) {
       Source partSource = oldParts[i];
       DartEntry partEntry = _getReadableDartEntry(partSource);
       if (partEntry != null && partEntry != dartEntry) {
         DartEntryImpl partCopy = partEntry.writableCopy;
         partCopy.removeContainingLibrary(librarySource);
-        if (partCopy.containingLibraries.length == 0 && !exists(partSource)) {
+        if (partCopy.librariesContaining.length == 0 && !exists(partSource)) {
           _cache.remove(partSource);
         } else {
           _cache.put(partSource, partCopy);
         }
       }
     }
   }
 
   /**
-   * Remove the given libraries that are keys in the given map from the list of containing libraries
-   * for each of the parts in the corresponding value.
-   *
-   * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
-   *
-   * @param oldPartMap the table containing the parts associated with each library
-   */
-  void _removeFromPartsUsingMap(Map<Source, List<Source>> oldPartMap) {
-    for (MapEntry<Source, List<Source>> entry in getMapEntrySet(oldPartMap)) {
-      Source librarySource = entry.getKey();
-      List<Source> oldParts = entry.getValue();
-      for (int i = 0; i < oldParts.length; i++) {
-        Source partSource = oldParts[i];
-        if (partSource != librarySource) {
-          DartEntry partEntry = _getReadableDartEntry(partSource);
-          if (partEntry != null) {
-            DartEntryImpl partCopy = partEntry.writableCopy;
-            partCopy.removeContainingLibrary(librarySource);
-            if (partCopy.containingLibraries.length == 0 && !exists(partSource)) {
-              _cache.remove(partSource);
-            } else {
-              _cache.put(partSource, partCopy);
-            }
-          }
-        }
-      }
-    }
-  }
-
-  /**
    * Remove the given source from the priority order if it is in the list.
    *
    * @param source the source to be removed
    */
   void _removeFromPriorityOrder(Source source) {
     int count = _priorityOrder.length;
     List<Source> newOrder = new List<Source>();
     for (int i = 0; i < count; i++) {
       if (_priorityOrder[i] != source) {
         newOrder.add(_priorityOrder[i]);
       }
     }
     if (newOrder.length < count) {
       analysisPriorityOrder = newOrder;
     }
   }
 
   /**
    * Create an entry for the newly added source. Return `true` if the new source is a Dart
    * file.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source that has been added
    * @return `true` if the new source is a Dart file
    */
   bool _sourceAvailable(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null) {
-      sourceEntry = _createSourceEntry(source, true);
+      sourceEntry = _createSourceEntry(source);
     } else {
       SourceEntryImpl sourceCopy = sourceEntry.writableCopy;
-      int newTime = getModificationStamp(source);
-      sourceCopy.modificationTime = newTime;
-      sourceCopy.explicitlyAdded = true;
-      // TODO(brianwilkerson) Understand why we're not invalidating the cached data.
+      //      long oldTime = sourceCopy.getModificationTime();
+      sourceCopy.modificationTime = getModificationStamp(source);
+      // TODO(brianwilkerson) Understand why we're not invalidating the cache.
       _cache.put(source, sourceCopy);
     }
     if (sourceEntry is HtmlEntry) {
       _workManager.add(source, SourcePriority.HTML);
     } else {
       _workManager.add(source, SourcePriority.UNKNOWN);
     }
     return sourceEntry is DartEntry;
   }
 
   /**
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source that has been changed
    */
   void _sourceChanged(Source source) {
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry == null || sourceEntry.modificationTime == getModificationStamp(source)) {
       // Either we have removed this source, in which case we don't care that it is changed, or we
       // have already invalidated the cache and don't need to invalidate it again.
+      //      if (sourceEntry == null) {
+      //        logInformation("Modified source, but there is no entry: " + debuggingString(source));
+      //      } else {
+      //        logInformation("Modified source, but modification time matches: " + debuggingString(source));
+      //      }
       return;
     }
     if (sourceEntry is HtmlEntry) {
       HtmlEntryImpl htmlCopy = sourceEntry.writableCopy;
+      //      long oldTime = htmlCopy.getModificationTime();
       htmlCopy.modificationTime = getModificationStamp(source);
       _invalidateAngularResolution(htmlCopy);
       htmlCopy.invalidateAllInformation();
       _cache.put(source, htmlCopy);
       _cache.removedAst(source);
       _workManager.add(source, SourcePriority.HTML);
     } else if (sourceEntry is DartEntry) {
       List<Source> containingLibraries = getLibrariesContaining(source);
       Set<Source> librariesToInvalidate = new Set<Source>();
       for (Source containingLibrary in containingLibraries) {
         librariesToInvalidate.add(containingLibrary);
         for (Source dependentLibrary in getLibrariesDependingOn(containingLibrary)) {
           librariesToInvalidate.add(dependentLibrary);
         }
       }
+      PrintStringWriter writer = new PrintStringWriter();
       for (Source library in librariesToInvalidate) {
         //    for (Source library : containingLibraries) {
-        _invalidateLibraryResolution(library);
+        _invalidateLibraryResolution(library, writer);
       }
       _removeFromParts(source, _cache.get(source) as DartEntry);
       DartEntryImpl dartCopy = (_cache.get(source) as DartEntry).writableCopy;
       dartCopy.modificationTime = getModificationStamp(source);
       dartCopy.invalidateAllInformation();
       _cache.put(source, dartCopy);
       _cache.removedAst(source);
       _workManager.add(source, SourcePriority.UNKNOWN);
     }
   }
 
   /**
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source that has been deleted
    */
   void _sourceRemoved(Source source) {
+    PrintStringWriter writer = new PrintStringWriter();
     SourceEntry sourceEntry = _cache.get(source);
     if (sourceEntry is HtmlEntry) {
       HtmlEntryImpl htmlCopy = sourceEntry.writableCopy;
       _invalidateAngularResolution(htmlCopy);
     } else if (sourceEntry is DartEntry) {
       Set<Source> libraries = new Set<Source>();
       for (Source librarySource in getLibrariesContaining(source)) {
         libraries.add(librarySource);
         for (Source dependentLibrary in getLibrariesDependingOn(librarySource)) {
           libraries.add(dependentLibrary);
         }
       }
       for (Source librarySource in libraries) {
-        _invalidateLibraryResolution(librarySource);
+        _invalidateLibraryResolution(librarySource, writer);
       }
     }
     _cache.remove(source);
     _workManager.remove(source);
     _removeFromPriorityOrder(source);
   }
 
   /**
    * Check the cache for any invalid entries (entries whose modification time does not match the
    * modification time of the source associated with the entry). Invalid entries will be marked as
@@ skipping 640 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.
    */
-  final bool _blocked;
+  bool _blocked = false;
 
   /**
    * 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
    */
-  AnalysisContextImpl_TaskData(this.task, this._blocked);
+  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;
 
   @override
   String toString() {
     if (task == null) {
       return "blocked: ${_blocked}";
     }
     return task.toString();
   }
 }
 
 /**
  * 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 432 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 1074 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.
    */
-  final Source source;
+  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.con1(int modificationTime, CompilationUnit unit) : this.con2(modificationTime, unit, null);
+  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, this.source) : super(modificationTime, 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.
@@ skipping 14 matching lines @@
 /**
  * The enumerated type `Priority` defines the priority levels used to return sources in an
  * 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 const SourcePriority PRIORITY_PART = const SourcePriority('PRIORITY_PART', 0);
+  static final SourcePriority PRIORITY_PART = new SourcePriority('PRIORITY_PART', 0);
 
   /**
    * Used for a Dart source that is known to be a library.
    */
-  static const SourcePriority LIBRARY = const SourcePriority('LIBRARY', 1);
+  static final SourcePriority LIBRARY = new SourcePriority('LIBRARY', 1);
 
   /**
    * Used for a Dart source whose kind is unknown.
    */
-  static const SourcePriority UNKNOWN = const SourcePriority('UNKNOWN', 2);
+  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 const SourcePriority NORMAL_PART = const SourcePriority('NORMAL_PART', 3);
+  static final SourcePriority NORMAL_PART = new SourcePriority('NORMAL_PART', 3);
 
   /**
    * Used for an HTML source.
    */
-  static const SourcePriority HTML = const SourcePriority('HTML', 4);
+  static final SourcePriority HTML = new SourcePriority('HTML', 4);
 
-  static const List<SourcePriority> values = const [PRIORITY_PART, LIBRARY, UNKNOWN, NORMAL_PART, HTML];
+  static final List<SourcePriority> values = [PRIORITY_PART, LIBRARY, UNKNOWN, NORMAL_PART, HTML];
 
-  const SourcePriority(String name, int ordinal) : super(name, ordinal);
+  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.
    */
@@ skipping 172 matching lines @@
   }
 }
 
 /**
  * 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 100 matching lines @@
   }
 
   static Set<Source> _getLibrarySources(Set<LibraryElement> libraries) {
     Set<Source> sources = new Set();
     for (LibraryElement library in libraries) {
       sources.add(library.source);
     }
     return sources;
   }
 
-  final InternalAnalysisContext _context;
+  InternalAnalysisContext _context;
 
   TypeProvider _typeProvider;
 
   AngularHtmlUnitResolver_FilteringAnalysisErrorListener _errorListener;
 
-  final Source _source;
+  Source _source;
 
-  final LineInfo _lineInfo;
+  LineInfo _lineInfo;
 
-  final ht.HtmlUnit _unit;
+  ht.HtmlUnit _unit;
 
   List<AngularElement> _angularElements;
 
   List<NgProcessor> _processors = [];
 
   LibraryElementImpl _libraryElement;
 
   CompilationUnitElementImpl _unitElement;
 
   FunctionElementImpl _functionElement;
 
   ResolverVisitor _resolver;
 
   bool _isAngular = false;
 
   List<LocalVariableElementImpl> _definedVariables = [];
 
   Set<LibraryElement> _injectedLibraries = new Set();
 
   Scope _topNameScope;
 
   Scope _nameScope;
 
-  AngularHtmlUnitResolver(this._context, AnalysisErrorListener errorListener, this._source, this._lineInfo, this._unit) {
-    this._typeProvider = _context.typeProvider;
+  AngularHtmlUnitResolver(InternalAnalysisContext context, AnalysisErrorListener errorListener, Source source, LineInfo lineInfo, ht.HtmlUnit unit) {
+    this._context = context;
+    this._typeProvider = context.typeProvider;
     this._errorListener = new AngularHtmlUnitResolver_FilteringAnalysisErrorListener(errorListener);
+    this._source = source;
+    this._lineInfo = lineInfo;
+    this._unit = unit;
   }
 
   /**
    * The [AngularApplication] for the Web application with this entry point, may be
    * `null` if not an entry point.
    */
   AngularApplication calculateAngularApplication() {
     // check if Angular at all
     if (!hasAngularAnnotation(_unit)) {
       return null;
@@ skipping 514 matching lines @@
    * The "ng-model" directive is special, it contributes to the top-level name scope. These models
    * can be used before actual "ng-model" attribute in HTML. So, we need to define them once we
    * found [NG_APP] context.
    */
   void _visitModelDirectives(ht.XmlTagNode appNode) {
     appNode.accept(new RecursiveXmlVisitor_AngularHtmlUnitResolver_visitModelDirectives(this));
   }
 }
 
 class AngularHtmlUnitResolver_FilteringAnalysisErrorListener implements AnalysisErrorListener {
-  final AnalysisErrorListener _listener;
+  AnalysisErrorListener _listener;
 
-  AngularHtmlUnitResolver_FilteringAnalysisErrorListener(this._listener);
+  AngularHtmlUnitResolver_FilteringAnalysisErrorListener(AnalysisErrorListener listener) {
+    this._listener = listener;
+  }
 
   @override
   void onError(AnalysisError error) {
     ErrorCode errorCode = error.errorCode;
     if (identical(errorCode, StaticWarningCode.UNDEFINED_GETTER) || identical(errorCode, StaticWarningCode.UNDEFINED_IDENTIFIER) || identical(errorCode, StaticTypeWarningCode.UNDEFINED_GETTER)) {
       return;
     }
     _listener.onError(error);
   }
 }
@@ skipping 39 matching lines @@
 
   static String CLOSING_DELIMITER = "}}";
 
   static int OPENING_DELIMITER_LENGTH = OPENING_DELIMITER.length;
 
   static int CLOSING_DELIMITER_LENGTH = CLOSING_DELIMITER.length;
 
   /**
    * The offset of the first character of the opening delimiter.
    */
-  final int _openingOffset;
+  int _openingOffset = 0;
 
   /**
    * The offset of the first character of the closing delimiter.
    */
-  final int _closingOffset;
+  int _closingOffset = 0;
 
-  AngularMoustacheXmlExpression(this._openingOffset, this._closingOffset, AngularExpression expression) : super(expression);
+  AngularMoustacheXmlExpression(int openingOffset, int closingOffset, AngularExpression expression) : super(expression) {
+    this._openingOffset = openingOffset;
+    this._closingOffset = closingOffset;
+  }
 
   @override
   int get end => _closingOffset + CLOSING_DELIMITER_LENGTH;
 
   @override
   int get length => _closingOffset + CLOSING_DELIMITER_LENGTH - _openingOffset;
 
   @override
   int get offset => _openingOffset;
 }
@@ skipping 15 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 68 matching lines @@
       }
     }
   }
 }
 
 /**
  * [NgComponentElementProcessor] applies [AngularComponentElement] by parsing mapped
  * attributes as expressions.
  */
 class NgComponentElementProcessor extends NgDirectiveProcessor {
-  final AngularComponentElement _element;
+  AngularComponentElement _element;
 
-  NgComponentElementProcessor(this._element);
+  NgComponentElementProcessor(AngularComponentElement element) {
+    this._element = element;
+  }
 
   @override
   void apply(AngularHtmlUnitResolver resolver, ht.XmlTagNode node) {
     node.element = _element.selector;
     for (AngularPropertyElement property in _element.properties) {
       String name = property.name;
       ht.XmlAttributeNode attribute = node.getAttribute(name);
       if (attribute != null) {
         attribute.element = property;
         // resolve if binding
         if (property.propertyKind != AngularPropertyKind.ATTR) {
           AngularExpression expression = parseAngularExpression(resolver, attribute);
           resolver._resolveExpression(expression);
           setAngularExpression(attribute, expression);
         }
       }
     }
   }
 
   @override
   bool canApply(ht.XmlTagNode node) => _element.selector.apply(node);
 }
 
 /**
  * [NgControllerElementProcessor] applies [AngularControllerElement].
  */
 class NgControllerElementProcessor extends NgProcessor {
-  final AngularControllerElement _element;
+  AngularControllerElement _element;
 
-  NgControllerElementProcessor(this._element);
+  NgControllerElementProcessor(AngularControllerElement element) {
+    this._element = element;
+  }
 
   @override
   void apply(AngularHtmlUnitResolver resolver, ht.XmlTagNode node) {
     InterfaceType type = (_element.enclosingElement as ClassElement).type;
     String name = _element.name;
     LocalVariableElementImpl variable = resolver._createLocalVariableWithName(type, name);
     resolver._defineVariable(variable);
     variable.toolkitObjects = <AngularElement> [_element];
   }
 
   @override
   bool canApply(ht.XmlTagNode node) => _element.selector.apply(node);
 }
 
 /**
  * [NgDirectiveElementProcessor] applies [AngularDirectiveElement] by parsing mapped
  * attributes as expressions.
  */
 class NgDirectiveElementProcessor extends NgDirectiveProcessor {
-  final AngularDirectiveElement _element;
+  AngularDirectiveElement _element;
 
-  NgDirectiveElementProcessor(this._element);
+  NgDirectiveElementProcessor(AngularDirectiveElement element) {
+    this._element = element;
+  }
 
   @override
   void apply(AngularHtmlUnitResolver resolver, ht.XmlTagNode node) {
     String selectorAttributeName = null;
     {
       AngularSelectorElement selector = _element.selector;
       if (selector is HasAttributeSelectorElementImpl) {
         selectorAttributeName = selector.name;
         // resolve attribute expression
         ht.XmlAttributeNode attribute = node.getAttribute(selectorAttributeName);
@@ skipping 173 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 181 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 time at which the contents of the source were last modified.
    */
-  final int modificationTime;
+  int modificationTime = 0;
 
   /**
    * The compilation unit used to resolve the dependencies.
    */
-  final CompilationUnit _unit;
+  CompilationUnit _unit;
 
   /**
    * The element model for the library containing the source.
    */
-  final LibraryElement libraryElement;
+  LibraryElement libraryElement;
 
   /**
    * 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 modificationTime the time at which the contents of the source were last modified
    * @param unit the compilation unit used to resolve the dependencies
    * @param libraryElement the element model for the library containing the source
    */
-  GenerateDartErrorsTask(InternalAnalysisContext context, this.source, this.modificationTime, this._unit, this.libraryElement) : super(context);
+  GenerateDartErrorsTask(InternalAnalysisContext context, Source source, int modificationTime, CompilationUnit unit, LibraryElement libraryElement) : super(context) {
+    this.source = source;
+    this.modificationTime = modificationTime;
+    this._unit = unit;
+    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 27 matching lines @@
 }
 
 /**
  * Instances of the class `GenerateDartHintsTask` generate hints for a single Dart library.
  */
 class GenerateDartHintsTask extends AnalysisTask {
   /**
    * The compilation units that comprise the library, with the defining compilation unit appearing
    * first in the array.
    */
-  final List<TimestampedData<CompilationUnit>> _units;
+  List<TimestampedData<CompilationUnit>> _units;
 
   /**
    * 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 units the compilation units that comprise the library, with the defining compilation
    *          unit appearing first in the array
    * @param libraryElement the element model for the library being analyzed
    */
-  GenerateDartHintsTask(InternalAnalysisContext context, this._units, this.libraryElement) : super(context);
+  GenerateDartHintsTask(InternalAnalysisContext context, List<TimestampedData<CompilationUnit>> units, LibraryElement libraryElement) : super(context) {
+    this._units = units;
+    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 39 matching lines @@
   }
 }
 
 /**
  * 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.
    */
-  final Token _tokenStream;
+  Token _tokenStream;
 
   /**
    * The line information associated with the source.
    */
-  final LineInfo lineInfo;
+  LineInfo lineInfo;
 
   /**
    * The compilation unit that was produced by parsing the source.
    */
   CompilationUnit _unit;
 
   /**
+   * A flag indicating whether the source contains a 'library' directive.
+   */
+  bool _containsLibraryDirective = false;
+
+  /**
    * A flag indicating whether the source contains a 'part of' directive.
    */
   bool _containsPartOfDirective = false;
 
   /**
-   * A flag indicating whether the source contains any directive other than a 'part of' directive.
-   */
-  bool _containsNonPartOfDirective = false;
-
-  /**
    * 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>();
 
   /**
@@ skipping 13 matching lines @@
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be parsed
    * @param 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, this._tokenStream, this.lineInfo) : 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
    */
@@ skipping 25 matching lines @@
 
   /**
    * 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 any directive other than 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 'library' directive, or `false` if the task
+   * has not yet been performed or if an exception occurred.
    *
-   * @return `true` if the source contains any directive other than a 'part of' directive
+   * @return `true` if the source contains a 'library' directive
    */
-  bool get hasNonPartOfDirective => _containsNonPartOfDirective;
+  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() {
     //
     // 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 PartOfDirective) {
+        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 && partSource != source) {
+            _includedSources.add(partSource);
+          }
+        } else if (directive is PartOfDirective) {
           _containsPartOfDirective = true;
-        } else {
-          _containsNonPartOfDirective = true;
-          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 && partSource != source) {
-              _includedSources.add(partSource);
-            }
-          }
         }
       }
-      _errors = errorListener.getErrorsForSource(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
@@ skipping 43 matching lines @@
   }
 }
 
 /**
  * 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.
    */
-  final String _content;
+  String _content;
 
   /**
    * The line information that was produced.
    */
   LineInfo _lineInfo;
 
   /**
    * The HTML unit that was produced by parsing the source.
    */
   ht.HtmlUnit _unit;
@@ skipping 19 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, this._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.
    *
    * @return the errors that were produced by scanning and parsing the source
    */
@@ skipping 91 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.
    */
-  final ht.HtmlUnit _unit;
+  ht.HtmlUnit _unit;
 
   /**
    * The [AngularComponentElement] to resolve template for.
    */
-  final AngularComponentElement _component;
+  AngularComponentElement _component;
 
   /**
    * The Angular application to resolve in context of.
    */
-  final AngularApplication _application;
+  AngularApplication _application;
 
   /**
    * The [HtmlUnit] that was resolved by this task.
    */
   ht.HtmlUnit _resolvedUnit;
 
   /**
    * The resolution errors that were discovered while resolving the source.
    */
   List<AnalysisError> _resolutionErrors = AnalysisError.NO_ERRORS;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be resolved
    * @param 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, this._unit, this._component, this._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;
 
   /**
    * Return the [HtmlUnit] that was resolved by this task.
    *
    * @return the [HtmlUnit] that was resolved by this task
@@ skipping 26 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.
    */
-  final ht.HtmlUnit _unit;
+  ht.HtmlUnit _unit;
 
   /**
    * The listener to record errors.
    */
   RecordingErrorListener _errorListener = new RecordingErrorListener();
 
   /**
    * The [HtmlUnit] that was resolved by this task.
    */
   ht.HtmlUnit _resolvedUnit;
 
   /**
    * The element produced by resolving the source.
    */
   HtmlElement _element = null;
 
   /**
    * The Angular application to resolve in context of.
    */
   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, this._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.
    */
   AngularApplication get application => _application;
 
@@ skipping 48 matching lines @@
 }
 
 /**
  * Instances of the class `ResolveDartLibraryTask` resolve a specific Dart library.
  */
 class ResolveDartLibraryCycleTask extends AnalysisTask {
   /**
    * The source representing the file whose compilation unit is to be returned. TODO(brianwilkerson)
    * This should probably be removed, but is being left in for now to ease the transition.
    */
-  final Source unitSource;
+  Source unitSource;
 
   /**
    * The source representing the library to be resolved.
    */
-  final Source librarySource;
+  Source librarySource;
 
   /**
    * The libraries that are part of the cycle containing the library to be resolved.
    */
-  final List<ResolvableLibrary> _librariesInCycle;
+  List<ResolvableLibrary> _librariesInCycle;
 
   /**
    * The library resolver holding information about the libraries that were resolved.
    */
   LibraryResolver2 _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
    * @param librariesInCycle the libraries that are part of the cycle containing the library to be
    *          resolved
    */
-  ResolveDartLibraryCycleTask(InternalAnalysisContext context, this.unitSource, this.librarySource, this._librariesInCycle) : super(context);
+  ResolveDartLibraryCycleTask(InternalAnalysisContext context, Source unitSource, Source librarySource, List<ResolvableLibrary> librariesInCycle) : super(context) {
+    this.unitSource = unitSource;
+    this.librarySource = librarySource;
+    this._librariesInCycle = librariesInCycle;
+  }
 
   @override
   accept(AnalysisTaskVisitor visitor) => visitor.visitResolveDartLibraryCycleTask(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
    */
   LibraryResolver2 get libraryResolver => _resolver;
@@ skipping 13 matching lines @@
   }
 }
 
 /**
  * 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.
    */
-  final LibraryElement _libraryElement;
+  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, this._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
    */
   Source get librarySource => _libraryElement.source;
@@ skipping 95 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.
    */
-  final ht.HtmlUnit _unit;
+  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, this._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;
 
   /**
    * Return the [HtmlUnit] that was resolved by this task.
@@ skipping 29 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.
    */
-  final String _content;
+  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, this._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.
    *
    * @return the errors that were produced by scanning the source
    */
@@ skipping 129 matching lines @@
   }
 
   @override
   void logInformation(String message) {
   }
 
   @override
   void logInformation2(String message, Exception exception) {
   }
 }