Fix for translation of \!= to \!identical(), but use == and \!= for Enum.

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.
    */
-  List<ChangeNotice> _notices;
+  final List<ChangeNotice> _notices;
 
   /**
    * The number of milliseconds required to determine which task was to be performed.
    */
-  int getTime = 0;
+  final int getTime;
 
   /**
    * The name of the class of the task that was performed.
    */
-  String taskClassName;
+  final String taskClassName;
 
   /**
    * The number of milliseconds required to perform the task.
    */
-  int performTime = 0;
+  final int performTime;
 
   /**
    * Initialize a newly created analysis result to have the given values.
    *
    * @param notices the change notices associated with this result
    * @param getTime the number of milliseconds required to determine which task was to be performed
    * @param taskClassName the name of the class of the task that was performed
    * @param performTime the number of milliseconds required to perform the task
    */
-  AnalysisResult(List<ChangeNotice> notices, int getTime, String taskClassName, int performTime) {
-    this._notices = notices;
-    this.getTime = getTime;
-    this.taskClassName = taskClassName;
-    this.performTime = performTime;
-  }
+  AnalysisResult(this._notices, this.getTime, this.taskClassName, this.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.
    */
-  CacheRetentionPolicy _retentionPolicy;
+  final 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, CacheRetentionPolicy retentionPolicy) {
+  AnalysisCache(int maxCacheSize, this._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 125 matching lines @@
    * cycle of libraries and the number of AST's being reserved is larger than the current cache
    * size.
    *
    * @return the source that was removed
    */
   Source _removeAstToFlush() {
     int sourceToRemove = -1;
     for (int i = 0; i < _recentlyUsed.length; i++) {
       Source source = _recentlyUsed[i];
       RetentionPriority priority = _retentionPolicy.getAstPriority(source, _sourceMap[source]);
-      if (identical(priority, RetentionPriority.LOW)) {
+      if (priority == RetentionPriority.LOW) {
         return _recentlyUsed.removeAt(i);
-      } else if (identical(priority, RetentionPriority.MEDIUM) && sourceToRemove < 0) {
+      } else if (priority == RetentionPriority.MEDIUM && sourceToRemove < 0) {
         sourceToRemove = i;
       }
     }
     if (sourceToRemove < 0) {
       return null;
     }
     return _recentlyUsed.removeAt(sourceToRemove);
   }
 }
 
@@ skipping 16 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 final CacheState ERROR = new CacheState('ERROR', 0);
+  static const CacheState ERROR = const 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 final CacheState FLUSHED = new CacheState('FLUSHED', 1);
+  static const CacheState FLUSHED = const 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 final CacheState IN_PROCESS = new CacheState('IN_PROCESS', 2);
+  static const CacheState IN_PROCESS = const 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 final CacheState INVALID = new CacheState('INVALID', 3);
+  static const CacheState INVALID = const 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 final CacheState VALID = new CacheState('VALID', 4);
+  static const CacheState VALID = const CacheState('VALID', 4);
 
-  static final List<CacheState> values = [ERROR, FLUSHED, IN_PROCESS, INVALID, VALID];
+  static const List<CacheState> values = const [ERROR, FLUSHED, IN_PROCESS, INVALID, VALID];
 
-  CacheState(String name, int ordinal) : super(name, ordinal);
+  const 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 bit in the [bitmask] indicating that this library is launchable: that
-   * the file has a main method.
+   * The index of the flag indicating whether this library is launchable (whether the file has a
+   * main method).
    */
   static int _LAUNCHABLE_INDEX = 1;
 
   /**
-   * The index of the bit in the [bitmask] indicating that the library is client code: that
-   * the library depends on the html library. If the library is not "client code", then it is
-   * referred to as "server code".
+   * 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".
    */
   static int _CLIENT_CODE_INDEX = 2;
 
   /**
    * Add the given library to the list of libraries that contain this part. This method should only
    * be invoked on entries that represent a part.
    *
    * @param librarySource the source of the library to be added
    */
   void addContainingLibrary(Source librarySource) {
     _containingLibraries.add(librarySource);
   }
 
   /**
    * Flush any AST structures being maintained by this entry.
    */
   void flushAstStructures() {
-    if (identical(_tokenStreamState, CacheState.VALID)) {
+    if (_tokenStreamState == CacheState.VALID) {
       _tokenStreamState = CacheState.FLUSHED;
       _tokenStream = null;
     }
-    if (identical(_parsedUnitState, CacheState.VALID)) {
+    if (_parsedUnitState == CacheState.VALID) {
       _parsedUnitState = CacheState.FLUSHED;
       _parsedUnitAccessed = false;
       _parsedUnit = null;
     }
     _resolutionState.flushAstStructures();
   }
 
   @override
   List<AnalysisError> get allErrors {
     List<AnalysisError> errors = new List<AnalysisError>();
     ListUtilities.addAll(errors, _scanErrors);
     ListUtilities.addAll(errors, _parseErrors);
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
       ListUtilities.addAll(errors, state._resolutionErrors);
       ListUtilities.addAll(errors, state._verificationErrors);
       ListUtilities.addAll(errors, state._hints);
       state = state._nextState;
     }
     ListUtilities.addAll(errors, _angularErrors);
     if (errors.length == 0) {
       return AnalysisError.NO_ERRORS;
     }
     return new List.from(errors);
   }
 
   @override
   CompilationUnit get anyParsedCompilationUnit {
-    if (identical(_parsedUnitState, CacheState.VALID)) {
+    if (_parsedUnitState == CacheState.VALID) {
       _parsedUnitAccessed = true;
       return _parsedUnit;
     }
     return anyResolvedCompilationUnit;
   }
 
   @override
   CompilationUnit get anyResolvedCompilationUnit {
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
-      if (identical(state._resolvedUnitState, CacheState.VALID)) {
+      if (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) {
       if (state._librarySource != null) {
         result.add(state._librarySource);
       }
       state = state._nextState;
     }
     return new List.from(result);
   }
 
   /**
    * Return a compilation unit that has not been accessed by any other client and can therefore
    * safely be modified by the reconciler, or `null` if the source has not been parsed.
    *
    * @return a compilation unit that can be modified by the reconciler
    */
   CompilationUnit get resolvableCompilationUnit {
-    if (identical(_parsedUnitState, CacheState.VALID)) {
+    if (_parsedUnitState == CacheState.VALID) {
       if (_parsedUnitAccessed) {
         return _parsedUnit.accept(new AstCloner()) as CompilationUnit;
       }
       CompilationUnit unit = _parsedUnit;
       _parsedUnitState = CacheState.FLUSHED;
       _parsedUnitAccessed = false;
       _parsedUnit = null;
       return unit;
     }
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
-      if (identical(state._resolvedUnitState, CacheState.VALID)) {
+      if (state._resolvedUnitState == CacheState.VALID) {
         return state._resolvedUnit.accept(new AstCloner()) as CompilationUnit;
       }
       state = state._nextState;
     }
     ;
     return null;
   }
 
   @override
   CacheState getState(DataDescriptor descriptor) {
@@ skipping 61 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 BooleanArray.get(_bitmask, _CLIENT_CODE_INDEX);
+      return getFlag(_CLIENT_CODE_INDEX);
     } else if (identical(descriptor, DartEntry.IS_LAUNCHABLE)) {
-      return BooleanArray.get(_bitmask, _LAUNCHABLE_INDEX);
+      return getFlag(_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 36 matching lines @@
   @override
   DartEntryImpl get writableCopy {
     DartEntryImpl copy = new DartEntryImpl();
     copy.copyFrom(this);
     return copy;
   }
 
   @override
   bool hasInvalidData(DataDescriptor descriptor) {
     if (identical(descriptor, DartEntry.ELEMENT)) {
-      return identical(_elementState, CacheState.INVALID);
+      return _elementState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.EXPORTED_LIBRARIES)) {
-      return identical(_exportedLibrariesState, CacheState.INVALID);
+      return _exportedLibrariesState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.IMPORTED_LIBRARIES)) {
-      return identical(_importedLibrariesState, CacheState.INVALID);
+      return _importedLibrariesState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.INCLUDED_PARTS)) {
-      return identical(_includedPartsState, CacheState.INVALID);
+      return _includedPartsState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.IS_CLIENT)) {
-      return identical(_clientServerState, CacheState.INVALID);
+      return _clientServerState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.IS_LAUNCHABLE)) {
-      return identical(_launchableState, CacheState.INVALID);
+      return _launchableState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.PARSE_ERRORS)) {
-      return identical(_parseErrorsState, CacheState.INVALID);
+      return _parseErrorsState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.PARSED_UNIT)) {
-      return identical(_parsedUnitState, CacheState.INVALID);
+      return _parsedUnitState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.PUBLIC_NAMESPACE)) {
-      return identical(_publicNamespaceState, CacheState.INVALID);
+      return _publicNamespaceState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.SCAN_ERRORS)) {
-      return identical(_scanErrorsState, CacheState.INVALID);
+      return _scanErrorsState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.SOURCE_KIND)) {
-      return identical(_sourceKindState, CacheState.INVALID);
+      return _sourceKindState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.TOKEN_STREAM)) {
-      return identical(_tokenStreamState, CacheState.INVALID);
+      return _tokenStreamState == CacheState.INVALID;
     } else if (identical(descriptor, DartEntry.RESOLUTION_ERRORS) || identical(descriptor, DartEntry.RESOLVED_UNIT) || identical(descriptor, DartEntry.VERIFICATION_ERRORS) || identical(descriptor, DartEntry.HINTS)) {
       DartEntryImpl_ResolutionState state = _resolutionState;
       while (state != null) {
         if (identical(descriptor, DartEntry.RESOLUTION_ERRORS)) {
-          return identical(state._resolutionErrorsState, CacheState.INVALID);
+          return state._resolutionErrorsState == CacheState.INVALID;
         } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
-          return identical(state._resolvedUnitState, CacheState.INVALID);
+          return state._resolvedUnitState == CacheState.INVALID;
         } else if (identical(descriptor, DartEntry.VERIFICATION_ERRORS)) {
-          return identical(state._verificationErrorsState, CacheState.INVALID);
+          return state._verificationErrorsState == CacheState.INVALID;
         } else if (identical(descriptor, DartEntry.HINTS)) {
-          return identical(state._hintsState, CacheState.INVALID);
+          return state._hintsState == CacheState.INVALID;
         }
       }
       return false;
     } else {
-      return identical(super.getState(descriptor), CacheState.INVALID);
+      return super.getState(descriptor) == CacheState.INVALID;
     }
   }
 
   @override
   bool get hasResolvableCompilationUnit {
-    if (identical(_parsedUnitState, CacheState.VALID)) {
+    if (_parsedUnitState == CacheState.VALID) {
       return true;
     }
     DartEntryImpl_ResolutionState state = _resolutionState;
     while (state != null) {
-      if (identical(state._resolvedUnitState, CacheState.VALID)) {
+      if (state._resolvedUnitState == CacheState.VALID) {
         return true;
       }
       state = state._nextState;
     }
     ;
     return false;
   }
 
   @override
   void invalidateAllInformation() {
@@ skipping 15 matching lines @@
     _exportedLibrariesState = CacheState.INVALID;
     _includedParts = Source.EMPTY_ARRAY;
     _includedPartsState = CacheState.INVALID;
     _discardCachedResolutionInformation();
   }
 
   /**
    * Invalidate all of the resolution information associated with the compilation unit.
    */
   void invalidateAllResolutionInformation() {
-    if (identical(_parsedUnitState, CacheState.FLUSHED)) {
+    if (_parsedUnitState == CacheState.FLUSHED) {
       DartEntryImpl_ResolutionState state = _resolutionState;
       while (state != null) {
-        if (identical(state._resolvedUnitState, CacheState.VALID)) {
+        if (state._resolvedUnitState == CacheState.VALID) {
           _parsedUnit = state._resolvedUnit;
           _parsedUnitAccessed = true;
           _parsedUnitState = CacheState.VALID;
           break;
         }
         state = state._nextState;
       }
     }
     _discardCachedResolutionInformation();
   }
@@ skipping 62 matching lines @@
     if (_includedPartsState != CacheState.VALID) {
       _includedPartsState = CacheState.IN_PROCESS;
     }
   }
 
   /**
    * Record that an in-process parse has stopped without recording results because the results were
    * invalidated before they could be recorded.
    */
   void recordParseNotInProcess() {
-    if (identical(getState(SourceEntry.LINE_INFO), CacheState.IN_PROCESS)) {
+    if (getState(SourceEntry.LINE_INFO) == CacheState.IN_PROCESS) {
       setState(SourceEntry.LINE_INFO, CacheState.INVALID);
     }
-    if (identical(_sourceKindState, CacheState.IN_PROCESS)) {
+    if (_sourceKindState == CacheState.IN_PROCESS) {
       _sourceKindState = CacheState.INVALID;
     }
-    if (identical(_parseErrorsState, CacheState.IN_PROCESS)) {
+    if (_parseErrorsState == CacheState.IN_PROCESS) {
       _parseErrorsState = CacheState.INVALID;
     }
-    if (identical(_parsedUnitState, CacheState.IN_PROCESS)) {
+    if (_parsedUnitState == CacheState.IN_PROCESS) {
       _parsedUnitState = CacheState.INVALID;
     }
-    if (identical(_exportedLibrariesState, CacheState.IN_PROCESS)) {
+    if (_exportedLibrariesState == CacheState.IN_PROCESS) {
       _exportedLibrariesState = CacheState.INVALID;
     }
-    if (identical(_importedLibrariesState, CacheState.IN_PROCESS)) {
+    if (_importedLibrariesState == CacheState.IN_PROCESS) {
       _importedLibrariesState = CacheState.INVALID;
     }
-    if (identical(_includedPartsState, CacheState.IN_PROCESS)) {
+    if (_includedPartsState == CacheState.IN_PROCESS) {
       _includedPartsState = CacheState.INVALID;
     }
   }
 
   /**
    * Record that an error occurred while attempting to scan or parse the entry represented by this
    * entry. This will set the state of all resolution-based information as being in error, but will
    * not change the state of any parse results.
    */
   void recordResolutionError() {
     _element = null;
     _elementState = CacheState.ERROR;
-    _bitmask = 0;
+    clearFlags([_LAUNCHABLE_INDEX, _CLIENT_CODE_INDEX]);
     _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.
    */
   void recordResolutionNotInProcess() {
-    if (identical(_elementState, CacheState.IN_PROCESS)) {
+    if (_elementState == CacheState.IN_PROCESS) {
       _elementState = CacheState.INVALID;
     }
-    if (identical(_clientServerState, CacheState.IN_PROCESS)) {
+    if (_clientServerState == CacheState.IN_PROCESS) {
       _clientServerState = CacheState.INVALID;
     }
-    if (identical(_launchableState, CacheState.IN_PROCESS)) {
+    if (_launchableState == CacheState.IN_PROCESS) {
       _launchableState = CacheState.INVALID;
     }
-    if (identical(_publicNamespaceState, CacheState.IN_PROCESS)) {
+    if (_publicNamespaceState == CacheState.IN_PROCESS) {
       _publicNamespaceState = CacheState.INVALID;
     }
     _resolutionState.recordResolutionNotInProcess();
   }
 
   /**
    * Record that an error occurred while attempting to scan or parse the entry represented by this
    * entry. This will set the state of all information, including any resolution-based information,
    * as being in error.
    */
@@ skipping 20 matching lines @@
     if (_tokenStreamState != CacheState.VALID) {
       _tokenStreamState = CacheState.IN_PROCESS;
     }
   }
 
   /**
    * Record that an in-process scan has stopped without recording results because the results were
    * invalidated before they could be recorded.
    */
   void recordScanNotInProcess() {
-    if (identical(getState(SourceEntry.LINE_INFO), CacheState.IN_PROCESS)) {
+    if (getState(SourceEntry.LINE_INFO) == CacheState.IN_PROCESS) {
       setState(SourceEntry.LINE_INFO, CacheState.INVALID);
     }
-    if (identical(_scanErrorsState, CacheState.IN_PROCESS)) {
+    if (_scanErrorsState == CacheState.IN_PROCESS) {
       _scanErrorsState = CacheState.INVALID;
     }
-    if (identical(_tokenStreamState, CacheState.IN_PROCESS)) {
+    if (_tokenStreamState == CacheState.IN_PROCESS) {
       _tokenStreamState = CacheState.INVALID;
     }
   }
 
   /**
    * Remove the given library from the list of libraries that contain this part. This method should
    * only be invoked on entries that represent a part.
    *
    * @param librarySource the source of the library to be removed
    */
@@ skipping 50 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)) {
-      _bitmask = _updatedValueOfFlag(state, _bitmask, _CLIENT_CODE_INDEX);
+      _updateValueOfFlag(_CLIENT_CODE_INDEX, state);
       _clientServerState = state;
     } else if (identical(descriptor, DartEntry.IS_LAUNCHABLE)) {
-      _bitmask = _updatedValueOfFlag(state, _bitmask, _LAUNCHABLE_INDEX);
+      _updateValueOfFlag(_LAUNCHABLE_INDEX, state);
       _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) {
+      if (!identical(newUnit, _parsedUnit)) {
         _parsedUnitAccessed = false;
       }
       _parsedUnit = newUnit;
       _parsedUnitState = state;
     } else if (identical(descriptor, DartEntry.PUBLIC_NAMESPACE)) {
       _publicNamespace = updatedValue(state, _publicNamespace, null);
       _publicNamespaceState = state;
     } else if (identical(descriptor, DartEntry.SCAN_ERRORS)) {
       _scanErrors = updatedValue(state, _scanErrors, AnalysisError.NO_ERRORS);
       _scanErrorsState = state;
@@ skipping 46 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)) {
-      _bitmask = BooleanArray.set(_bitmask, _CLIENT_CODE_INDEX, value as bool);
+      setFlag(_CLIENT_CODE_INDEX, value as bool);
       _clientServerState = CacheState.VALID;
     } else if (identical(descriptor, DartEntry.IS_LAUNCHABLE)) {
-      _bitmask = BooleanArray.set(_bitmask, _LAUNCHABLE_INDEX, value as bool);
+      setFlag(_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;
+  bool get hasErrorState => super.hasErrorState || _scanErrorsState == CacheState.ERROR || _tokenStreamState == CacheState.ERROR || _sourceKindState == CacheState.ERROR || _parsedUnitState == CacheState.ERROR || _parseErrorsState == CacheState.ERROR || _importedLibrariesState == CacheState.ERROR || _exportedLibrariesState == CacheState.ERROR || _includedPartsState == CacheState.ERROR || _elementState == CacheState.ERROR || _publicNamespaceState == CacheState.ERROR || _clientServerState == CacheState.ERROR || _launchableState == CacheState.ERROR || _resolutionState.hasErrorState;
 
   @override
   void writeOn(JavaStringBuilder builder) {
     builder.append("Dart: ");
     super.writeOn(builder);
     builder.append("; tokenStream = ");
     builder.append(_tokenStreamState);
     builder.append("; scanErrors = ");
     builder.append(_scanErrorsState);
     builder.append("; sourceKind = ");
@@ skipping 21 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;
-    _bitmask = 0;
+    clearFlags([_LAUNCHABLE_INDEX, _CLIENT_CODE_INDEX]);
     _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 one of the flags is being transitioned to the given state, return the value of the
-   * flags that should be kept in the cache.
+   * 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.
    *
-   * @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
+   * @param index the index of the flag whose state is being set
+   * @param state the state to which the value is being transitioned
    */
-  int _updatedValueOfFlag(CacheState state, int currentValue, int bitIndex) {
-    if (identical(state, CacheState.VALID)) {
+  void _updateValueOfFlag(int index, CacheState state) {
+    if (state == CacheState.VALID) {
       throw new IllegalArgumentException("Use setValue() to set the state to VALID");
-    } else if (identical(state, CacheState.IN_PROCESS)) {
+    } else if (state != CacheState.IN_PROCESS) {
       //
-      // We can leave the current value in the cache for any 'get' methods to access.
+      // If the value is in process, we can leave the current value in the cache for any 'get'
+      // methods to access.
       //
-      return currentValue;
+      setFlag(index, false);
     }
-    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 70 matching lines @@
     if (other._nextState != null) {
       _nextState = new DartEntryImpl_ResolutionState();
       _nextState.copyFrom(other._nextState);
     }
   }
 
   /**
    * Flush any AST structures being maintained by this state.
    */
   void flushAstStructures() {
-    if (identical(_resolvedUnitState, CacheState.VALID)) {
+    if (_resolvedUnitState == CacheState.VALID) {
       _resolvedUnitState = CacheState.FLUSHED;
       _resolvedUnit = null;
     }
     if (_nextState != null) {
       _nextState.flushAstStructures();
     }
   }
 
-  bool get hasErrorState => identical(_resolvedUnitState, CacheState.ERROR) || identical(_resolutionErrorsState, CacheState.ERROR) || identical(_verificationErrorsState, CacheState.ERROR) || identical(_hintsState, CacheState.ERROR) || (_nextState != null && _nextState.hasErrorState);
+  bool get hasErrorState => _resolvedUnitState == CacheState.ERROR || _resolutionErrorsState == CacheState.ERROR || _verificationErrorsState == CacheState.ERROR || _hintsState == CacheState.ERROR || (_nextState != null && _nextState.hasErrorState);
 
   /**
    * Invalidate all of the resolution information associated with the compilation unit.
    */
   void invalidateAllResolutionInformation() {
     _nextState = null;
     _librarySource = null;
     _resolvedUnitState = CacheState.INVALID;
     _resolvedUnit = null;
     _resolutionErrorsState = CacheState.INVALID;
@@ skipping 21 matching lines @@
     if (_nextState != null) {
       _nextState.recordResolutionError();
     }
   }
 
   /**
    * Record that an in-process parse has stopped without recording results because the results
    * were invalidated before they could be recorded.
    */
   void recordResolutionNotInProcess() {
-    if (identical(_resolvedUnitState, CacheState.IN_PROCESS)) {
+    if (_resolvedUnitState == CacheState.IN_PROCESS) {
       _resolvedUnitState = CacheState.INVALID;
     }
-    if (identical(_resolutionErrorsState, CacheState.IN_PROCESS)) {
+    if (_resolutionErrorsState == CacheState.IN_PROCESS) {
       _resolutionErrorsState = CacheState.INVALID;
     }
-    if (identical(_verificationErrorsState, CacheState.IN_PROCESS)) {
+    if (_verificationErrorsState == CacheState.IN_PROCESS) {
       _verificationErrorsState = CacheState.INVALID;
     }
-    if (identical(_hintsState, CacheState.IN_PROCESS)) {
+    if (_hintsState == CacheState.IN_PROCESS) {
       _hintsState = CacheState.INVALID;
     }
     if (_nextState != null) {
       _nextState.recordResolutionNotInProcess();
     }
   }
 
   /**
    * Write a textual representation of this state to the given builder. The result will only be
    * used for debugging purposes.
@@ skipping 18 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.
    */
-  String _name;
+  final String _name;
 
   /**
    * Initialize a newly created descriptor to have the given name.
    *
    * @param name the name of the descriptor
    */
-  DataDescriptor(String name) {
-    this._name = name;
-  }
+  DataDescriptor(this._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 190 matching lines @@
   /**
    * The hints produced while auditing the compilation unit, or an empty array if the hints are not
    * currently cached.
    */
   List<AnalysisError> _hints = AnalysisError.NO_ERRORS;
 
   /**
    * Flush any AST structures being maintained by this entry.
    */
   void flushAstStructures() {
-    if (identical(_parsedUnitState, CacheState.VALID)) {
+    if (_parsedUnitState == CacheState.VALID) {
       _parsedUnitState = CacheState.FLUSHED;
       _parsedUnit = null;
     }
-    if (identical(_resolvedUnitState, CacheState.VALID)) {
+    if (_resolvedUnitState == CacheState.VALID) {
       _resolvedUnitState = CacheState.FLUSHED;
       _resolvedUnit = null;
     }
-    if (identical(_angularEntryState, CacheState.VALID)) {
+    if (_angularEntryState == CacheState.VALID) {
       _angularEntryState = CacheState.FLUSHED;
     }
-    if (identical(_angularErrorsState, CacheState.VALID)) {
+    if (_angularErrorsState == CacheState.VALID) {
       _angularErrorsState = CacheState.FLUSHED;
     }
   }
 
   @override
   List<AnalysisError> get allErrors {
     List<AnalysisError> errors = new List<AnalysisError>();
     if (_parseErrors != null) {
       for (AnalysisError error in _parseErrors) {
         errors.add(error);
@@ skipping 15 matching lines @@
       }
     }
     if (errors.length == 0) {
       return AnalysisError.NO_ERRORS;
     }
     return new List.from(errors);
   }
 
   @override
   ht.HtmlUnit get anyParsedUnit {
-    if (identical(_parsedUnitState, CacheState.VALID)) {
+    if (_parsedUnitState == CacheState.VALID) {
       //      parsedUnitAccessed = true;
       return _parsedUnit;
     }
-    if (identical(_resolvedUnitState, CacheState.VALID)) {
+    if (_resolvedUnitState == CacheState.VALID) {
       //      resovledUnitAccessed = true;
       return _resolvedUnit;
     }
     return null;
   }
 
   @override
   SourceKind get kind => SourceKind.HTML;
 
   @override
@@ skipping 221 matching lines @@
     _referencedLibraries = other._referencedLibraries;
     _resolutionErrors = other._resolutionErrors;
     _resolutionErrorsState = other._resolutionErrorsState;
     _elementState = other._elementState;
     _element = other._element;
     _hints = other._hints;
     _hintsState = other._hintsState;
   }
 
   @override
-  bool get hasErrorState => super.hasErrorState || identical(_parsedUnitState, CacheState.ERROR) || identical(_resolvedUnitState, CacheState.ERROR) || identical(_parseErrorsState, CacheState.ERROR) || identical(_resolutionErrorsState, CacheState.ERROR) || identical(_referencedLibrariesState, CacheState.ERROR) || identical(_elementState, CacheState.ERROR) || identical(_angularErrorsState, CacheState.ERROR) || identical(_hintsState, CacheState.ERROR);
+  bool get hasErrorState => super.hasErrorState || _parsedUnitState == CacheState.ERROR || _resolvedUnitState == CacheState.ERROR || _parseErrorsState == CacheState.ERROR || _resolutionErrorsState == CacheState.ERROR || _referencedLibrariesState == CacheState.ERROR || _elementState == CacheState.ERROR || _angularErrorsState == CacheState.ERROR || _hintsState == CacheState.ERROR;
 
   @override
   void writeOn(JavaStringBuilder builder) {
     builder.append("Html: ");
     super.writeOn(builder);
     builder.append("; parseErrors = ");
     builder.append(_parseErrorsState);
     builder.append("; parsedUnit = ");
     builder.append(_parsedUnitState);
     builder.append("; resolvedUnit = ");
@@ skipping 17 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 final RetentionPriority LOW = new RetentionPriority('LOW', 0);
+  static const RetentionPriority LOW = const RetentionPriority('LOW', 0);
 
   /**
    * A priority indicating that a given piece of data should not be removed from the cache unless
    * there are no sources for which the corresponding data has a lower priority. Currently used for
    * data that is needed in order to finish some outstanding analysis task.
    */
-  static final RetentionPriority MEDIUM = new RetentionPriority('MEDIUM', 1);
+  static const RetentionPriority MEDIUM = const RetentionPriority('MEDIUM', 1);
 
   /**
    * A priority indicating that a given piece of data should not be removed from the cache.
    * Currently used for data related to a priority source.
    */
-  static final RetentionPriority HIGH = new RetentionPriority('HIGH', 2);
+  static const RetentionPriority HIGH = const RetentionPriority('HIGH', 2);
 
-  static final List<RetentionPriority> values = [LOW, MEDIUM, HIGH];
+  static const List<RetentionPriority> values = const [LOW, MEDIUM, HIGH];
 
-  RetentionPriority(String name, int ordinal) : super(name, ordinal);
+  const 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);
+  bool get hasErrorState => _contentState == CacheState.ERROR || _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)) {
+    if (state == CacheState.VALID) {
       throw new IllegalArgumentException("Use setValue() to set the state to VALID");
-    } else if (identical(state, CacheState.IN_PROCESS)) {
+    } else if (state == CacheState.IN_PROCESS) {
       //
       // We can leave the current value in the cache for any 'get' methods to access.
       //
       return currentValue;
     }
     return defaultValue;
   }
 
   /**
    * Write a textual representation of this entry to the given builder. The result will only be used
@@ skipping 46 matching lines @@
   }
 
   void _internalPutCacheItem(SourceEntry dartEntry, DataDescriptor rowDesc, CacheState state) {
     String rowName = rowDesc.toString();
     AnalysisContentStatisticsImpl_CacheRowImpl row = _dataMap[rowName] as AnalysisContentStatisticsImpl_CacheRowImpl;
     if (row == null) {
       row = new AnalysisContentStatisticsImpl_CacheRowImpl(rowName);
       _dataMap[rowName] = row;
     }
     row._incState(state);
-    if (identical(state, CacheState.ERROR)) {
+    if (state == CacheState.ERROR) {
       AnalysisException exception = dartEntry.exception;
       if (exception != null) {
         _exceptions.add(exception);
       }
     }
   }
 }
 
 class AnalysisContentStatisticsImpl_CacheRowImpl implements AnalysisContentStatistics_CacheRow {
-  String name;
+  final String name;
 
   int _errorCount = 0;
 
   int _flushedCount = 0;
 
   int _inProcessCount = 0;
 
   int _invalidCount = 0;
 
   int _validCount = 0;
 
-  AnalysisContentStatisticsImpl_CacheRowImpl(String name) {
-    this.name = name;
-  }
+  AnalysisContentStatisticsImpl_CacheRowImpl(this.name);
 
   @override
   bool operator ==(Object obj) => obj is AnalysisContentStatisticsImpl_CacheRowImpl && obj.name == name;
 
   @override
   int get errorCount => _errorCount;
 
   @override
   int get flushedCount => _flushedCount;
 
   @override
   int get inProcessCount => _inProcessCount;
 
   @override
   int get invalidCount => _invalidCount;
 
   @override
   int get validCount => _validCount;
 
   @override
   int get hashCode => name.hashCode;
 
   void _incState(CacheState state) {
-    if (identical(state, CacheState.ERROR)) {
+    if (state == CacheState.ERROR) {
       _errorCount++;
     }
-    if (identical(state, CacheState.FLUSHED)) {
+    if (state == CacheState.FLUSHED) {
       _flushedCount++;
     }
-    if (identical(state, CacheState.IN_PROCESS)) {
+    if (state == CacheState.IN_PROCESS) {
       _inProcessCount++;
     }
-    if (identical(state, CacheState.INVALID)) {
+    if (state == CacheState.INVALID) {
       _invalidCount++;
     }
-    if (identical(state, CacheState.VALID)) {
+    if (state == CacheState.VALID) {
       _validCount++;
     }
   }
 }
 
 /**
  * Instances of the class `AnalysisContextImpl` implement an [AnalysisContext].
  */
 class AnalysisContextImpl implements InternalAnalysisContext {
   /**
@@ skipping 160 matching lines @@
       int count = sourcesToInvalidate.length;
       for (int i = 0; i < count; i++) {
         Source source = sourcesToInvalidate[i];
         DartEntry dartEntry = _getReadableDartEntry(source);
         _removeFromParts(source, dartEntry);
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         dartCopy.invalidateAllResolutionInformation();
         _cache.put(source, dartCopy);
         SourcePriority priority = SourcePriority.UNKNOWN;
         SourceKind kind = dartCopy.kind;
-        if (identical(kind, SourceKind.LIBRARY)) {
+        if (kind == SourceKind.LIBRARY) {
           priority = SourcePriority.LIBRARY;
-        } else if (identical(kind, SourceKind.PART)) {
+        } else if (kind == SourceKind.PART) {
           priority = SourcePriority.NORMAL_PART;
         }
         _workManager.add(source, priority);
       }
     }
   }
 
   @override
   String computeDocumentationComment(Element element) {
     if (element == null) {
@@ skipping 35 matching lines @@
     bool enableHints = _options.hint;
     SourceEntry sourceEntry = _getReadableSourceEntry(source);
     if (sourceEntry is DartEntry) {
       List<AnalysisError> errors = new List<AnalysisError>();
       try {
         DartEntry dartEntry = sourceEntry;
         ListUtilities.addAll(errors, _getDartScanData(source, dartEntry, DartEntry.SCAN_ERRORS));
         dartEntry = _getReadableDartEntry(source);
         ListUtilities.addAll(errors, _getDartParseData(source, dartEntry, DartEntry.PARSE_ERRORS));
         dartEntry = _getReadableDartEntry(source);
-        if (identical(dartEntry.getValue(DartEntry.SOURCE_KIND), SourceKind.LIBRARY)) {
+        if (dartEntry.getValue(DartEntry.SOURCE_KIND) == SourceKind.LIBRARY) {
           ListUtilities.addAll(errors, _getDartResolutionData(source, source, dartEntry, DartEntry.RESOLUTION_ERRORS));
           dartEntry = _getReadableDartEntry(source);
           ListUtilities.addAll(errors, _getDartVerificationData(source, source, dartEntry, DartEntry.VERIFICATION_ERRORS));
           if (enableHints) {
             dartEntry = _getReadableDartEntry(source);
             ListUtilities.addAll(errors, _getDartHintData(source, source, dartEntry, DartEntry.HINTS));
           }
         } else {
           List<Source> libraries = getLibrariesContaining(source);
           for (Source librarySource in libraries) {
@@ skipping 207 matching lines @@
     if (sourceKind == null) {
       return Source.EMPTY_ARRAY;
     }
     List<Source> htmlSources = new List<Source>();
     while (true) {
       if (sourceKind == SourceKind.LIBRARY) {
       } else if (sourceKind == SourceKind.PART) {
         List<Source> librarySources = getLibrariesContaining(source);
         for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
           SourceEntry sourceEntry = entry.getValue();
-          if (identical(sourceEntry.kind, SourceKind.HTML)) {
+          if (sourceEntry.kind == SourceKind.HTML) {
             List<Source> referencedLibraries = (sourceEntry as HtmlEntry).getValue(HtmlEntry.REFERENCED_LIBRARIES);
             if (_containsAny(referencedLibraries, librarySources)) {
               htmlSources.add(entry.getKey());
             }
           }
         }
       }
       break;
     }
     if (htmlSources.isEmpty) {
@@ skipping 15 matching lines @@
   }
 
   @override
   List<Source> get launchableClientLibrarySources {
     // TODO(brianwilkerson) This needs to filter out libraries that do not reference dart:html,
     // either directly or indirectly.
     List<Source> sources = new List<Source>();
     for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
       Source source = entry.getKey();
       SourceEntry sourceEntry = entry.getValue();
-      if (identical(sourceEntry.kind, SourceKind.LIBRARY) && !source.isInSystemLibrary) {
+      if (sourceEntry.kind == SourceKind.LIBRARY && !source.isInSystemLibrary) {
         //          DartEntry dartEntry = (DartEntry) sourceEntry;
         //          if (dartEntry.getValue(DartEntry.IS_LAUNCHABLE) && dartEntry.getValue(DartEntry.IS_CLIENT)) {
         sources.add(source);
       }
     }
     return new List.from(sources);
   }
 
   @override
   List<Source> get launchableServerLibrarySources {
     // TODO(brianwilkerson) This needs to filter out libraries that reference dart:html, either
     // directly or indirectly.
     List<Source> sources = new List<Source>();
     for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
       Source source = entry.getKey();
       SourceEntry sourceEntry = entry.getValue();
-      if (identical(sourceEntry.kind, SourceKind.LIBRARY) && !source.isInSystemLibrary) {
+      if (sourceEntry.kind == SourceKind.LIBRARY && !source.isInSystemLibrary) {
         //          DartEntry dartEntry = (DartEntry) sourceEntry;
         //          if (dartEntry.getValue(DartEntry.IS_LAUNCHABLE) && !dartEntry.getValue(DartEntry.IS_CLIENT)) {
         sources.add(source);
       }
     }
     return new List.from(sources);
   }
 
   @override
   List<Source> getLibrariesContaining(Source source) {
     SourceEntry sourceEntry = _getReadableSourceEntryOrNull(source);
     if (sourceEntry is DartEntry) {
       return sourceEntry.getValue(DartEntry.CONTAINING_LIBRARIES);
     }
     return Source.EMPTY_ARRAY;
   }
 
   @override
   List<Source> getLibrariesDependingOn(Source librarySource) {
     List<Source> dependentLibraries = new List<Source>();
     for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
       SourceEntry sourceEntry = entry.getValue();
-      if (identical(sourceEntry.kind, SourceKind.LIBRARY)) {
+      if (sourceEntry.kind == SourceKind.LIBRARY) {
         if (_contains((sourceEntry as DartEntry).getValue(DartEntry.EXPORTED_LIBRARIES), librarySource)) {
           dependentLibraries.add(entry.getKey());
         }
         if (_contains((sourceEntry as DartEntry).getValue(DartEntry.IMPORTED_LIBRARIES), librarySource)) {
           dependentLibraries.add(entry.getKey());
         }
       }
     }
     if (dependentLibraries.isEmpty) {
       return Source.EMPTY_ARRAY;
@@ skipping 149 matching lines @@
       SourceEntry entry = mapEntry.getValue();
       if (entry is DartEntry) {
         Source source = mapEntry.getKey();
         DartEntry dartEntry = entry;
         SourceKind kind = dartEntry.getValue(DartEntry.SOURCE_KIND);
         // get library independent values
         statistics.putCacheItem(dartEntry, SourceEntry.LINE_INFO);
         statistics.putCacheItem(dartEntry, DartEntry.PARSE_ERRORS);
         statistics.putCacheItem(dartEntry, DartEntry.PARSED_UNIT);
         statistics.putCacheItem(dartEntry, DartEntry.SOURCE_KIND);
-        if (identical(kind, SourceKind.LIBRARY)) {
+        if (kind == SourceKind.LIBRARY) {
           statistics.putCacheItem(dartEntry, DartEntry.ELEMENT);
           statistics.putCacheItem(dartEntry, DartEntry.EXPORTED_LIBRARIES);
           statistics.putCacheItem(dartEntry, DartEntry.IMPORTED_LIBRARIES);
           statistics.putCacheItem(dartEntry, DartEntry.INCLUDED_PARTS);
           statistics.putCacheItem(dartEntry, DartEntry.IS_CLIENT);
           statistics.putCacheItem(dartEntry, DartEntry.IS_LAUNCHABLE);
         }
         // get library-specific values
         List<Source> librarySources = getLibrariesContaining(source);
         for (Source librarySource in librarySources) {
@@ skipping 335 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;
             }
-            if (_generateSdkErrors || !source.isInSystemLibrary) {
-              ChangeNoticeImpl notice = _getNotice(source);
-              notice.compilationUnit = unit;
-              notice.setErrors(dartCopy.allErrors, lineInfo);
-            }
+            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;
             }
-            if (_generateSdkErrors || !source.isInSystemLibrary) {
-              ChangeNoticeImpl notice = _getNotice(source);
-              notice.compilationUnit = unit;
-              notice.setErrors(dartCopy.allErrors, lineInfo);
-            }
+            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.
+   * 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.
    *
-   * @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 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 libraryEntry the entry for the library
    * @return task data representing the created task
    */
-  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) {
+  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);
     }
-    CompilationUnit unit = dartEntry.getValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource);
+    CompilationUnit unit = unitEntry.getValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource);
     LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
-    DartEntryImpl dartCopy = dartEntry.writableCopy;
+    DartEntryImpl dartCopy = unitEntry.writableCopy;
     dartCopy.setStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.IN_PROCESS);
-    _cache.put(source, dartCopy);
-    return new AnalysisContextImpl_TaskData(new GenerateDartErrorsTask(this, source, dartCopy.modificationTime, unit, libraryElement), false);
+    _cache.put(unitSource, dartCopy);
+    return new AnalysisContextImpl_TaskData(new GenerateDartErrorsTask(this, unitSource, 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) {
+  SourceEntry _createSourceEntry(Source source, bool explicitlyAdded) {
     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 318 matching lines @@
         hasBlockedTask = true;
       }
     }
     if (_neededForResolution != null) {
       List<Source> sourcesToRemove = new List<Source>();
       for (Source source in _neededForResolution) {
         SourceEntry sourceEntry = _cache.get(source);
         if (sourceEntry is DartEntry) {
           DartEntry dartEntry = sourceEntry;
           if (!dartEntry.hasResolvableCompilationUnit) {
-            if (identical(dartEntry.getState(DartEntry.PARSED_UNIT), CacheState.ERROR)) {
+            if (dartEntry.getState(DartEntry.PARSED_UNIT) == CacheState.ERROR) {
               sourcesToRemove.add(source);
             } else {
               AnalysisContextImpl_TaskData taskData = _createParseDartTask(source, dartEntry);
               AnalysisTask task = taskData.task;
               if (task != null) {
                 return task;
               } else if (taskData.isBlocked) {
                 hasBlockedTask = true;
               }
             }
@@ skipping 60 matching lines @@
    * @param sourceEntry the cache entry associated with the source
    * @param isPriority `true` if the source is a priority source
    * @param hintsEnabled `true` if hints are currently enabled
    * @return the next task that needs to be performed for the given source
    */
   AnalysisContextImpl_TaskData _getNextAnalysisTaskForSource(Source source, SourceEntry sourceEntry, bool isPriority, bool hintsEnabled) {
     if (sourceEntry == null) {
       return new AnalysisContextImpl_TaskData(null, false);
     }
     CacheState contentState = sourceEntry.getState(SourceEntry.CONTENT);
-    if (identical(contentState, CacheState.INVALID)) {
+    if (contentState == CacheState.INVALID) {
       return _createGetContentTask(source, sourceEntry);
-    } else if (identical(contentState, CacheState.IN_PROCESS)) {
+    } else if (contentState == CacheState.IN_PROCESS) {
       // We are already in the process of getting the content. There's nothing else we can do with
       // this source until that's complete.
       return new AnalysisContextImpl_TaskData(null, true);
-    } else if (identical(contentState, CacheState.ERROR)) {
+    } else if (contentState == CacheState.ERROR) {
       // We have done all of the analysis we can for this source because we cannot get its content.
       return new AnalysisContextImpl_TaskData(null, false);
     }
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       CacheState scanErrorsState = dartEntry.getState(DartEntry.SCAN_ERRORS);
-      if (identical(scanErrorsState, CacheState.INVALID) || (isPriority && identical(scanErrorsState, CacheState.FLUSHED))) {
+      if (scanErrorsState == CacheState.INVALID || (isPriority && scanErrorsState == CacheState.FLUSHED)) {
         return _createScanDartTask(source, dartEntry);
       }
       CacheState parseErrorsState = dartEntry.getState(DartEntry.PARSE_ERRORS);
-      if (identical(parseErrorsState, CacheState.INVALID) || (isPriority && identical(parseErrorsState, CacheState.FLUSHED))) {
+      if (parseErrorsState == CacheState.INVALID || (isPriority && parseErrorsState == CacheState.FLUSHED)) {
         return _createParseDartTask(source, dartEntry);
       }
       if (isPriority && parseErrorsState != CacheState.ERROR) {
         if (!dartEntry.hasResolvableCompilationUnit) {
           return _createParseDartTask(source, dartEntry);
         }
       }
       SourceKind kind = dartEntry.getValue(DartEntry.SOURCE_KIND);
-      if (identical(kind, SourceKind.UNKNOWN)) {
+      if (kind == SourceKind.UNKNOWN) {
         return _createParseDartTask(source, dartEntry);
-      } else if (identical(kind, SourceKind.LIBRARY)) {
+      } else if (kind == SourceKind.LIBRARY) {
         CacheState elementState = dartEntry.getState(DartEntry.ELEMENT);
-        if (identical(elementState, CacheState.INVALID)) {
+        if (elementState == CacheState.INVALID) {
           return _createResolveDartLibraryTask(source, dartEntry);
         }
       }
       List<Source> librariesContaining = dartEntry.getValue(DartEntry.CONTAINING_LIBRARIES);
       for (Source librarySource in librariesContaining) {
-        SourceEntry libraryEntry = _cache.get(librarySource);
-        if (libraryEntry is DartEntry) {
+        SourceEntry librarySourceEntry = _cache.get(librarySource);
+        if (librarySourceEntry is DartEntry) {
+          DartEntry libraryEntry = librarySourceEntry;
           CacheState elementState = libraryEntry.getState(DartEntry.ELEMENT);
-          if (identical(elementState, CacheState.INVALID) || (isPriority && identical(elementState, CacheState.FLUSHED))) {
+          if (elementState == CacheState.INVALID || (isPriority && 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))) {
+          if (resolvedUnitState == CacheState.INVALID || (isPriority && resolvedUnitState == CacheState.FLUSHED)) {
             //
             // The commented out lines below are an optimization that doesn't quite work yet. The
             // problem is that if the source was not resolved because it wasn't part of any library,
             // then there won't be any elements in the element model that we can use to resolve it.
             //
             //LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
             //if (libraryElement != null) {
             //  return new ResolveDartUnitTask(this, source, libraryElement);
             //}
             // Possibly replace with: return createResolveDartLibraryTask(librarySource, (DartEntry) libraryEntry);
             DartEntryImpl dartCopy = dartEntry.writableCopy;
             dartCopy.setStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource, CacheState.IN_PROCESS);
             _cache.put(source, dartCopy);
             return new AnalysisContextImpl_TaskData(new ResolveDartLibraryTask(this, source, librarySource), false);
           }
           if (_generateSdkErrors || !source.isInSystemLibrary) {
             CacheState verificationErrorsState = dartEntry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource);
-            if (identical(verificationErrorsState, CacheState.INVALID) || (isPriority && identical(verificationErrorsState, CacheState.FLUSHED))) {
+            if (verificationErrorsState == CacheState.INVALID || (isPriority && verificationErrorsState == CacheState.FLUSHED)) {
               return _createGenerateDartErrorsTask(source, dartEntry, librarySource, libraryEntry);
             }
             if (hintsEnabled) {
               CacheState hintsState = dartEntry.getStateInLibrary(DartEntry.HINTS, librarySource);
-              if (identical(hintsState, CacheState.INVALID) || (isPriority && identical(hintsState, CacheState.FLUSHED))) {
+              if (hintsState == CacheState.INVALID || (isPriority && hintsState == CacheState.FLUSHED)) {
                 return _createGenerateDartHintsTask(source, dartEntry, librarySource, libraryEntry);
               }
             }
           }
         }
       }
     } else if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       CacheState parseErrorsState = htmlEntry.getState(HtmlEntry.PARSE_ERRORS);
-      if (identical(parseErrorsState, CacheState.INVALID) || (isPriority && identical(parseErrorsState, CacheState.FLUSHED))) {
+      if (parseErrorsState == CacheState.INVALID || (isPriority && parseErrorsState == CacheState.FLUSHED)) {
         return _createParseHtmlTask(source, htmlEntry);
       }
       if (isPriority && parseErrorsState != CacheState.ERROR) {
         ht.HtmlUnit parsedUnit = htmlEntry.anyParsedUnit;
         if (parsedUnit == null) {
           return _createParseHtmlTask(source, htmlEntry);
         }
       }
       CacheState resolvedUnitState = htmlEntry.getState(HtmlEntry.RESOLVED_UNIT);
-      if (identical(resolvedUnitState, CacheState.INVALID) || (isPriority && identical(resolvedUnitState, CacheState.FLUSHED))) {
+      if (resolvedUnitState == CacheState.INVALID || (isPriority && resolvedUnitState == CacheState.FLUSHED)) {
         return _createResolveHtmlTask(source, htmlEntry);
       }
       //
       // Angular support
       //
       if (_options.analyzeAngular) {
         // Try to resolve the HTML as an Angular entry point.
         CacheState angularEntryState = htmlEntry.getState(HtmlEntry.ANGULAR_ENTRY);
-        if (identical(angularEntryState, CacheState.INVALID) || (isPriority && identical(angularEntryState, CacheState.FLUSHED))) {
+        if (angularEntryState == CacheState.INVALID || (isPriority && angularEntryState == CacheState.FLUSHED)) {
           return _createResolveAngularEntryHtmlTask(source, htmlEntry);
         }
         // Try to resolve the HTML as an Angular application part.
         CacheState angularErrorsState = htmlEntry.getState(HtmlEntry.ANGULAR_ERRORS);
-        if (identical(angularErrorsState, CacheState.INVALID) || (isPriority && identical(angularErrorsState, CacheState.FLUSHED))) {
+        if (angularErrorsState == CacheState.INVALID || (isPriority && angularErrorsState == CacheState.FLUSHED)) {
           return _createResolveAngularComponentTemplateTask(source, htmlEntry);
         }
       }
     }
     return new AnalysisContextImpl_TaskData(null, false);
   }
 
   /**
    * Return a change notice for the given source, creating one if one does not already exist.
    *
@@ skipping 12 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);
+      sourceEntry = _createSourceEntry(source, false);
     }
     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);
+      sourceEntry = _createSourceEntry(source, false);
     }
     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);
+      sourceEntry = _createSourceEntry(source, false);
     }
     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
    */
   SourceEntry _getReadableSourceEntryOrNull(Source source) => _cache.get(source);
 
   /**
    * Return a resolved compilation unit corresponding to the given element in the given library, or
    * `null` if the information is not cached.
    *
    * @param element the element representing the compilation unit
    * @param librarySource the source representing the library containing the unit
    * @return the specified resolved compilation unit
    */
   TimestampedData<CompilationUnit> _getResolvedUnit(CompilationUnitElement element, Source librarySource) {
     SourceEntry sourceEntry = _cache.get(element.source);
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
-      if (identical(dartEntry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource), CacheState.VALID)) {
+      if (dartEntry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource) == CacheState.VALID) {
         return new TimestampedData<CompilationUnit>(dartEntry.modificationTime, dartEntry.getValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource));
       }
     }
     return null;
   }
 
   /**
    * Return an array containing all of the sources known to this context that have the given kind.
    *
    * @param kind the kind of sources to be returned
    * @return all of the sources known to this context that have the given kind
    */
   List<Source> _getSources(SourceKind kind) {
     List<Source> sources = new List<Source>();
     for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
-      if (identical(entry.getValue().kind, kind)) {
+      if (entry.getValue().kind == kind) {
         sources.add(entry.getKey());
       }
     }
     return new List.from(sources);
   }
 
   /**
    * Look at the given source to see whether a task needs to be performed related to it. If so, add
    * the source to the set of sources that need to be processed. This method duplicates, and must
    * therefore be kept in sync with,
    * [getNextAnalysisTask]. This method is intended to
    * be used for testing purposes only.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param source the source to be checked
    * @param sourceEntry the cache entry associated with the source
    * @param isPriority `true` if the source is a priority source
    * @param hintsEnabled `true` if hints are currently enabled
    * @param sources the set to which sources should be added
    */
   void _getSourcesNeedingProcessing(Source source, SourceEntry sourceEntry, bool isPriority, bool hintsEnabled, Set<Source> sources) {
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry;
       CacheState scanErrorsState = dartEntry.getState(DartEntry.SCAN_ERRORS);
-      if (identical(scanErrorsState, CacheState.INVALID) || (isPriority && identical(scanErrorsState, CacheState.FLUSHED))) {
+      if (scanErrorsState == CacheState.INVALID || (isPriority && scanErrorsState == CacheState.FLUSHED)) {
         sources.add(source);
         return;
       }
       CacheState parseErrorsState = dartEntry.getState(DartEntry.PARSE_ERRORS);
-      if (identical(parseErrorsState, CacheState.INVALID) || (isPriority && identical(parseErrorsState, CacheState.FLUSHED))) {
+      if (parseErrorsState == CacheState.INVALID || (isPriority && parseErrorsState == CacheState.FLUSHED)) {
         sources.add(source);
         return;
       }
       if (isPriority) {
         if (!dartEntry.hasResolvableCompilationUnit) {
           sources.add(source);
           return;
         }
       }
       for (Source librarySource in getLibrariesContaining(source)) {
         SourceEntry libraryEntry = _cache.get(librarySource);
         if (libraryEntry is DartEntry) {
           CacheState elementState = libraryEntry.getState(DartEntry.ELEMENT);
-          if (identical(elementState, CacheState.INVALID) || (isPriority && identical(elementState, CacheState.FLUSHED))) {
+          if (elementState == CacheState.INVALID || (isPriority && elementState == CacheState.FLUSHED)) {
             sources.add(source);
             return;
           }
           CacheState resolvedUnitState = dartEntry.getStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource);
-          if (identical(resolvedUnitState, CacheState.INVALID) || (isPriority && identical(resolvedUnitState, CacheState.FLUSHED))) {
+          if (resolvedUnitState == CacheState.INVALID || (isPriority && resolvedUnitState == CacheState.FLUSHED)) {
             LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
             if (libraryElement != null) {
               sources.add(source);
               return;
             }
           }
           CacheState verificationErrorsState = dartEntry.getStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource);
-          if (identical(verificationErrorsState, CacheState.INVALID) || (isPriority && identical(verificationErrorsState, CacheState.FLUSHED))) {
+          if (verificationErrorsState == CacheState.INVALID || (isPriority && verificationErrorsState == CacheState.FLUSHED)) {
             LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
             if (libraryElement != null) {
               sources.add(source);
               return;
             }
           }
           if (hintsEnabled) {
             CacheState hintsState = dartEntry.getStateInLibrary(DartEntry.HINTS, librarySource);
-            if (identical(hintsState, CacheState.INVALID) || (isPriority && identical(hintsState, CacheState.FLUSHED))) {
+            if (hintsState == CacheState.INVALID || (isPriority && hintsState == CacheState.FLUSHED)) {
               LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
               if (libraryElement != null) {
                 sources.add(source);
                 return;
               }
             }
           }
         }
       }
     } else if (sourceEntry is HtmlEntry) {
       HtmlEntry htmlEntry = sourceEntry;
       CacheState parsedUnitState = htmlEntry.getState(HtmlEntry.PARSED_UNIT);
-      if (identical(parsedUnitState, CacheState.INVALID) || (isPriority && identical(parsedUnitState, CacheState.FLUSHED))) {
+      if (parsedUnitState == CacheState.INVALID || (isPriority && parsedUnitState == CacheState.FLUSHED)) {
         sources.add(source);
         return;
       }
       CacheState resolvedUnitState = htmlEntry.getState(HtmlEntry.RESOLVED_UNIT);
-      if (identical(resolvedUnitState, CacheState.INVALID) || (isPriority && identical(resolvedUnitState, CacheState.FLUSHED))) {
+      if (resolvedUnitState == CacheState.INVALID || (isPriority && resolvedUnitState == CacheState.FLUSHED)) {
         sources.add(source);
         return;
       }
       // Angular
       if (_options.analyzeAngular) {
         CacheState angularErrorsState = htmlEntry.getState(HtmlEntry.ANGULAR_ERRORS);
-        if (identical(angularErrorsState, CacheState.INVALID) || (isPriority && identical(angularErrorsState, CacheState.FLUSHED))) {
+        if (angularErrorsState == CacheState.INVALID || (isPriority && angularErrorsState == CacheState.FLUSHED)) {
           AngularApplication entryInfo = htmlEntry.getValue(HtmlEntry.ANGULAR_ENTRY);
           if (entryInfo != null) {
             sources.add(source);
             return;
           }
           AngularApplication applicationInfo = htmlEntry.getValue(HtmlEntry.ANGULAR_APPLICATION);
           if (applicationInfo != null) {
             AngularComponentElement component = htmlEntry.getValue(HtmlEntry.ANGULAR_COMPONENT);
             if (component != null) {
               sources.add(source);
               return;
             }
           }
         }
       }
     }
   }
 
   /**
    * 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;
-        _removeFromParts(source, dartEntry);
+        oldPartMap[source] = dartEntry.getValue(DartEntry.INCLUDED_PARTS);
         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
-      if (_generateSdkErrors || !elementSource.isInSystemLibrary) {
-        ChangeNoticeImpl notice = _getNotice(elementSource);
-        notice.setErrors(dartCopy.allErrors, dartEntry.getValue(SourceEntry.LINE_INFO));
-      }
+      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, 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
+  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
     // 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
-        if (_generateSdkErrors || !elementSource.isInSystemLibrary) {
-          ChangeNoticeImpl notice = _getNotice(elementSource);
-          notice.setErrors(dartCopy.allErrors, computeLineInfo(elementSource));
-        }
+        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);
-        if (_generateSdkErrors || !source.isInSystemLibrary) {
-          ChangeNoticeImpl notice = _getNotice(source);
-          notice.setErrors(dartCopy.allErrors, dartCopy.getValue(SourceEntry.LINE_INFO));
-        }
+        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);
-          if (_generateSdkErrors || !unitSource.isInSystemLibrary) {
-            ChangeNoticeImpl notice = _getNotice(unitSource);
-            notice.setErrors(dartCopy.allErrors, dartCopy.getValue(SourceEntry.LINE_INFO));
-          }
+          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)) {
+        if (dartEntry.getStateInLibrary(DartEntry.HINTS, librarySource) == CacheState.IN_PROCESS) {
           DartEntryImpl dartCopy = dartEntry.writableCopy;
           if (thrownException == null || resultTime >= 0) {
             //
             // The analysis was performed on out-of-date sources. Mark the cache so that the sources
             // will be re-analyzed using the up-to-date sources.
             //
             //              dartCopy.setState(DartEntry.HINTS, librarySource, CacheState.INVALID);
             _removeFromParts(unitSource, dartEntry);
             dartCopy.invalidateAllInformation();
             dartCopy.modificationTime = sourceTime;
@@ skipping 57 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) {
-      if (_generateSdkErrors || !task.source.isInSystemLibrary) {
-        ChangeNoticeImpl notice = _getNotice(task.source);
-        notice.compilationUnit = unit;
-      }
+      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.hasPartOfDirective && !task.hasLibraryDirective) {
+        if (task.hasNonPartOfDirective) {
+          dartCopy.setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY);
+          dartCopy.containingLibrary = source;
+          _workManager.add(source, SourcePriority.LIBRARY);
+        } else if (task.hasPartOfDirective) {
           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);
+          // 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);
+          }
         }
         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) {
+          if (partEntry != null && !identical(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);
-        if (_generateSdkErrors || !source.isInSystemLibrary) {
-          ChangeNoticeImpl notice = _getNotice(source);
-          notice.setErrors(dartCopy.allErrors, task.lineInfo);
-        }
+        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);
-        if (_generateSdkErrors || !source.isInSystemLibrary) {
-          ChangeNoticeImpl notice = _getNotice(source);
-          notice.setErrors(htmlCopy.allErrors, lineInfo);
-        }
+        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
-        if (_generateSdkErrors || !source.isInSystemLibrary) {
-          ChangeNoticeImpl notice = _getNotice(source);
-          notice.htmlUnit = task.resolvedUnit;
-          notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
-        }
+        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);
-        if (_generateSdkErrors || !source.isInSystemLibrary) {
-          ChangeNoticeImpl notice = _getNotice(source);
-          notice.htmlUnit = task.resolvedUnit;
-          notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
-        }
+        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);
-        if (_generateSdkErrors || !source.isInSystemLibrary) {
-          ChangeNoticeImpl notice = _getNotice(source);
-          notice.htmlUnit = task.resolvedUnit;
-          notice.setErrors(htmlCopy.allErrors, htmlCopy.getValue(SourceEntry.LINE_INFO));
-        }
+        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);
-        if (_generateSdkErrors || !source.isInSystemLibrary) {
-          ChangeNoticeImpl notice = _getNotice(source);
-          notice.setErrors(dartEntry.allErrors, lineInfo);
-        }
+        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 34 matching lines @@
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    *
    * @param librarySource the library to be removed
    * @param dartEntry the entry containing the list of included parts
    */
   void _removeFromParts(Source librarySource, DartEntry dartEntry) {
     List<Source> oldParts = dartEntry.getValue(DartEntry.INCLUDED_PARTS);
     for (int i = 0; i < oldParts.length; i++) {
       Source partSource = oldParts[i];
       DartEntry partEntry = _getReadableDartEntry(partSource);
-      if (partEntry != null && partEntry != dartEntry) {
+      if (partEntry != null && !identical(partEntry, dartEntry)) {
         DartEntryImpl partCopy = partEntry.writableCopy;
         partCopy.removeContainingLibrary(librarySource);
-        if (partCopy.librariesContaining.length == 0 && !exists(partSource)) {
+        if (partCopy.containingLibraries.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);
+      sourceEntry = _createSourceEntry(source, true);
     } else {
       SourceEntryImpl sourceCopy = sourceEntry.writableCopy;
-      //      long oldTime = sourceCopy.getModificationTime();
-      sourceCopy.modificationTime = getModificationStamp(source);
-      // TODO(brianwilkerson) Understand why we're not invalidating the cache.
+      int newTime = getModificationStamp(source);
+      sourceCopy.modificationTime = newTime;
+      sourceCopy.explicitlyAdded = true;
+      // TODO(brianwilkerson) Understand why we're not invalidating the cached data.
       _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, writer);
+        _invalidateLibraryResolution(library);
       }
       _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, writer);
+        _invalidateLibraryResolution(librarySource);
       }
     }
     _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 613 matching lines @@
    * @param source the source with which the sources are associated
    * @param dartEntry the entry corresponding to the source
    * @param descriptor the descriptor indicating which sources are to be returned
    * @return the sources described by the given descriptor
    */
   List<Source> _getSources(Source source, DartEntry dartEntry, DataDescriptor<List<Source>> descriptor) {
     if (dartEntry == null) {
       return Source.EMPTY_ARRAY;
     }
     CacheState exportState = dartEntry.getState(descriptor);
-    if (identical(exportState, CacheState.ERROR)) {
+    if (exportState == CacheState.ERROR) {
       return Source.EMPTY_ARRAY;
     } else if (exportState != CacheState.VALID) {
       if (_taskData == null) {
         _taskData = AnalysisContextImpl_this._createParseDartTask(source, dartEntry);
       }
       return Source.EMPTY_ARRAY;
     }
     return dartEntry.getValue(descriptor);
   }
 }
 
 /**
  * Instances of the class `TaskData` represent information about the next task to be
  * performed. Each data has an implicit associated source: the source that might need to be
  * analyzed. There are essentially three states that can be represented:
  * * If [getTask] returns a non-`null` value, then that is the task that should
  * be executed to further analyze the associated source.
  * * Otherwise, if [isBlocked] returns `true`, then there is no work that can be
  * done, but analysis for the associated source is not complete.
  * * Otherwise, [getDependentSource] should return a source that needs to be analyzed
  * before the analysis of the associated source can be completed.
  */
 class AnalysisContextImpl_TaskData {
   /**
    * The task that is to be performed.
    */
-  AnalysisTask task;
+  final AnalysisTask task;
 
   /**
    * A flag indicating whether the associated source is blocked waiting for its contents to be
    * loaded.
    */
-  bool _blocked = false;
+  final bool _blocked;
 
   /**
    * 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(AnalysisTask task, bool blocked) {
-    this.task = task;
-    this._blocked = blocked;
-  }
+  AnalysisContextImpl_TaskData(this.task, this._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.
    */
-  List<AnalysisError> errors;
+  final List<AnalysisError> errors;
 
   /**
    * The line information associated with the errors, or `null` if there are no errors.
    */
-  LineInfo lineInfo;
+  final 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(List<AnalysisError> errors, LineInfo lineInfo) {
-    this.errors = errors;
-    this.lineInfo = lineInfo;
-  }
+  AnalysisErrorInfoImpl(this.errors, this.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.
    */
-  Source source;
+  final 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(Source source) {
-    this.source = source;
-  }
+  ChangeNoticeImpl(this.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;
   }
 
-  Source librarySource;
+  final Source librarySource;
 
-  Source source;
+  final Source source;
 
-  String oldContents;
+  final String oldContents;
 
-  CompilationUnit resolvedUnit;
+  final CompilationUnit resolvedUnit;
 
   String _newContents;
 
   int _offset = 0;
 
   int _oldLength = 0;
 
   int _newLength = 0;
 
-  IncrementalAnalysisCache(Source librarySource, Source source, CompilationUnit resolvedUnit, String oldContents, String newContents, int offset, int oldLength, int newLength) {
-    this.librarySource = librarySource;
-    this.source = source;
-    this.resolvedUnit = resolvedUnit;
-    this.oldContents = oldContents;
+  IncrementalAnalysisCache(this.librarySource, this.source, this.resolvedUnit, this.oldContents, String newContents, int offset, int oldLength, int newLength) {
     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.
    */
-  Source _source;
+  final 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) : super(modificationTime, unit);
+  ResolvableCompilationUnit.con1(int modificationTime, CompilationUnit unit) : this.con2(modificationTime, unit, null);
 
   /**
    * Initialize a newly created holder to hold the given values.
    *
    * @param modificationTime the modification time of the source from which the AST was created
    * @param unit the AST that was created from the source
    * @param source the source of the compilation unit
    */
-  ResolvableCompilationUnit.con2(int modificationTime, CompilationUnit unit, Source source) : super(modificationTime, unit) {
-    this._source = source;
-  }
+  ResolvableCompilationUnit.con2(int modificationTime, CompilationUnit unit, this.source) : super(modificationTime, unit);
 
   /**
    * Return the AST that was created from the source.
    *
    * @return the AST that was created from the source
    */
   CompilationUnit get compilationUnit => data;
-
-  /**
-   * 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 final SourcePriority PRIORITY_PART = new SourcePriority('PRIORITY_PART', 0);
+  static const SourcePriority PRIORITY_PART = const SourcePriority('PRIORITY_PART', 0);
 
   /**
    * Used for a Dart source that is known to be a library.
    */
-  static final SourcePriority LIBRARY = new SourcePriority('LIBRARY', 1);
+  static const SourcePriority LIBRARY = const SourcePriority('LIBRARY', 1);
 
   /**
    * Used for a Dart source whose kind is unknown.
    */
-  static final SourcePriority UNKNOWN = new SourcePriority('UNKNOWN', 2);
+  static const SourcePriority UNKNOWN = const SourcePriority('UNKNOWN', 2);
 
   /**
    * Used for a Dart source that is known to be a part but whose library has not yet been resolved.
    */
-  static final SourcePriority NORMAL_PART = new SourcePriority('NORMAL_PART', 3);
+  static const SourcePriority NORMAL_PART = const SourcePriority('NORMAL_PART', 3);
 
   /**
    * Used for an HTML source.
    */
-  static final SourcePriority HTML = new SourcePriority('HTML', 4);
+  static const SourcePriority HTML = const SourcePriority('HTML', 4);
 
-  static final List<SourcePriority> values = [PRIORITY_PART, LIBRARY, UNKNOWN, NORMAL_PART, HTML];
+  static const List<SourcePriority> values = const [PRIORITY_PART, LIBRARY, UNKNOWN, NORMAL_PART, HTML];
 
-  SourcePriority(String name, int ordinal) : super(name, ordinal);
+  const 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.
    */
-  int modificationTime = 0;
+  final int modificationTime;
 
   /**
    * The data that was created from the source.
    */
-  E data;
+  final E data;
 
   /**
    * Initialize a newly created holder to hold the given values.
    *
    * @param modificationTime the modification time of the source from which the data was created
    * @param unit the data that was created from the source
    */
-  TimestampedData(int modificationTime, E data) {
-    this.modificationTime = modificationTime;
-    this.data = data;
-  }
+  TimestampedData(this.modificationTime, this.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.
    */
-  Expression expression;
+  final Expression expression;
 
   /**
    * The filters to apply.
    */
-  List<AngularFilterNode> filters;
+  final List<AngularFilterNode> filters;
 
-  AngularExpression(Expression expression, List<AngularFilterNode> filters) {
-    this.expression = expression;
-    this.filters = filters;
-  }
+  AngularExpression(this.expression, this.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.
    */
-  Token token;
+  final Token token;
 
   /**
    * The argument expression.
    */
-  Expression expression;
+  final Expression expression;
 
   /**
    * The optional sub-[Expression]s.
    */
   List<Expression> subExpressions = Expression.EMPTY_ARRAY;
 
-  AngularFilterArgument(Token token, Expression expression) {
-    this.token = token;
-    this.expression = expression;
-  }
+  AngularFilterArgument(this.token, this.expression);
 }
 
 /**
  * Angular filter node.
  */
 class AngularFilterNode {
   /**
    * The [TokenType#BAR] token.
    */
-  Token token;
+  final Token token;
 
   /**
    * The name of the filter.
    */
-  SimpleIdentifier name;
+  final SimpleIdentifier name;
 
   /**
    * The arguments for this filter.
    */
-  List<AngularFilterArgument> arguments;
+  final List<AngularFilterArgument> arguments;
 
-  AngularFilterNode(Token token, SimpleIdentifier name, List<AngularFilterArgument> arguments) {
-    this.token = token;
-    this.name = name;
-    this.arguments = arguments;
-  }
+  AngularFilterNode(this.token, this.name, this.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;
   }
 
-  InternalAnalysisContext _context;
+  final InternalAnalysisContext _context;
 
   TypeProvider _typeProvider;
 
   AngularHtmlUnitResolver_FilteringAnalysisErrorListener _errorListener;
 
-  Source _source;
+  final Source _source;
 
-  LineInfo _lineInfo;
+  final LineInfo _lineInfo;
 
-  ht.HtmlUnit _unit;
+  final 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(InternalAnalysisContext context, AnalysisErrorListener errorListener, Source source, LineInfo lineInfo, ht.HtmlUnit unit) {
-    this._context = context;
-    this._typeProvider = context.typeProvider;
+  AngularHtmlUnitResolver(this._context, AnalysisErrorListener errorListener, this._source, this._lineInfo, this._unit) {
+    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 190 matching lines @@
       Token barToken = filterToken;
       filterToken = filterToken.next;
       // TODO(scheglov) report missing identifier
       SimpleIdentifier name = _parseDartExpressionInToken(filterToken) as SimpleIdentifier;
       filterToken = name.endToken.next;
       // parse arguments
       List<AngularFilterArgument> arguments = [];
       while (filterToken.type != TokenType.EOF) {
         // skip ":"
         Token colonToken = filterToken;
-        if (identical(colonToken.type, TokenType.COLON)) {
+        if (colonToken.type == TokenType.COLON) {
           filterToken = filterToken.next;
         } else {
           _reportErrorForToken(AngularCode.MISSING_FILTER_COLON, colonToken, []);
         }
         // parse argument
         Expression argument = _parseDartExpressionInToken(filterToken);
         arguments.add(new AngularFilterArgument(colonToken, argument));
         // next token
         filterToken = argument.endToken.next;
       }
@@ skipping 172 matching lines @@
     if (!expressions.isEmpty) {
       node.expressions = new List.from(expressions);
     }
   }
 
   void _parseEmbeddedExpressionsInTag(ht.XmlTagNode node) {
     List<AngularMoustacheXmlExpression> expressions = [];
     ht.Token token = node.attributeEnd;
     ht.Token endToken = node.endToken;
     bool inChild = false;
-    while (token != endToken) {
+    while (!identical(token, endToken)) {
       for (ht.XmlTagNode child in node.tagNodes) {
         if (identical(token, child.beginToken)) {
           inChild = true;
           break;
         }
         if (identical(token, child.endToken)) {
           inChild = false;
           break;
         }
       }
-      if (!inChild && identical(token.type, ht.TokenType.TEXT)) {
+      if (!inChild && token.type == ht.TokenType.TEXT) {
         _parseEmbeddedExpressions(expressions, token);
       }
       token = token.next;
     }
     node.expressions = new List.from(expressions);
   }
 
   void _recordDefinedVariable(LocalVariableElementImpl variable) {
     _definedVariables.add(variable);
     _functionElement.localVariables = new List.from(_definedVariables);
@@ skipping 78 matching lines @@
 
   void _resolveXmlExpression(AngularXmlExpression angularXmlExpression) {
     AngularExpression angularExpression = angularXmlExpression.expression;
     _resolveExpression(angularExpression);
   }
 
   List<Token> _splitAtBar(Token token) {
     List<Token> tokens = [];
     tokens.add(token);
     while (token.type != TokenType.EOF) {
-      if (identical(token.type, TokenType.BAR)) {
+      if (token.type == TokenType.BAR) {
         tokens.add(token);
         Token eofToken = new Token(TokenType.EOF, 0);
         token.previous.setNext(eofToken);
       }
       token = token.next;
     }
     return tokens;
   }
 
   /**
    * The "ng-model" directive is special, it contributes to the top-level name scope. These models
    * can be used before actual "ng-model" attribute in HTML. So, we need to define them once we
    * found [NG_APP] context.
    */
   void _visitModelDirectives(ht.XmlTagNode appNode) {
     appNode.accept(new RecursiveXmlVisitor_AngularHtmlUnitResolver_visitModelDirectives(this));
   }
 }
 
 class AngularHtmlUnitResolver_FilteringAnalysisErrorListener implements AnalysisErrorListener {
-  AnalysisErrorListener _listener;
+  final AnalysisErrorListener _listener;
 
-  AngularHtmlUnitResolver_FilteringAnalysisErrorListener(AnalysisErrorListener listener) {
-    this._listener = listener;
-  }
+  AngularHtmlUnitResolver_FilteringAnalysisErrorListener(this._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.
    */
-  int _openingOffset = 0;
+  final int _openingOffset;
 
   /**
    * The offset of the first character of the closing delimiter.
    */
-  int _closingOffset = 0;
+  final int _closingOffset;
 
-  AngularMoustacheXmlExpression(int openingOffset, int closingOffset, AngularExpression expression) : super(expression) {
-    this._openingOffset = openingOffset;
-    this._closingOffset = closingOffset;
-  }
+  AngularMoustacheXmlExpression(this._openingOffset, this._closingOffset, AngularExpression expression) : super(expression);
 
   @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.
    */
-  AngularExpression expression;
+  final AngularExpression expression;
 
-  AngularXmlExpression(AngularExpression expression) {
-    this.expression = expression;
-  }
+  AngularXmlExpression(this.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 {
-  AngularComponentElement _element;
+  final AngularComponentElement _element;
 
-  NgComponentElementProcessor(AngularComponentElement element) {
-    this._element = element;
-  }
+  NgComponentElementProcessor(this._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 {
-  AngularControllerElement _element;
+  final AngularControllerElement _element;
 
-  NgControllerElementProcessor(AngularControllerElement element) {
-    this._element = element;
-  }
+  NgControllerElementProcessor(this._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 {
-  AngularDirectiveElement _element;
+  final AngularDirectiveElement _element;
 
-  NgDirectiveElementProcessor(AngularDirectiveElement element) {
-    this._element = element;
-  }
+  NgDirectiveElementProcessor(this._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.
    */
-  InternalAnalysisContext context;
+  final 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(InternalAnalysisContext context) {
-    this.context = context;
-  }
+  AnalysisTask(this.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.
    */
-  Source source;
+  final Source source;
 
   /**
    * The time at which the contents of the source were last modified.
    */
-  int modificationTime = 0;
+  final int modificationTime;
 
   /**
    * The compilation unit used to resolve the dependencies.
    */
-  CompilationUnit _unit;
+  final CompilationUnit _unit;
 
   /**
    * The element model for the library containing the source.
    */
-  LibraryElement libraryElement;
+  final 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, Source source, int modificationTime, CompilationUnit unit, LibraryElement libraryElement) : super(context) {
-    this.source = source;
-    this.modificationTime = modificationTime;
-    this._unit = unit;
-    this.libraryElement = libraryElement;
-  }
+  GenerateDartErrorsTask(InternalAnalysisContext context, this.source, this.modificationTime, this._unit, this.libraryElement) : super(context);
 
   @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.
    */
-  List<TimestampedData<CompilationUnit>> _units;
+  final List<TimestampedData<CompilationUnit>> _units;
 
   /**
    * The element model for the library being analyzed.
    */
-  LibraryElement libraryElement;
+  final 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, List<TimestampedData<CompilationUnit>> units, LibraryElement libraryElement) : super(context) {
-    this._units = units;
-    this.libraryElement = libraryElement;
-  }
+  GenerateDartHintsTask(InternalAnalysisContext context, this._units, this.libraryElement) : super(context);
 
   @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.
    */
-  Source source;
+  final Source source;
 
   /**
    * A flag indicating whether this task is complete.
    */
   bool _complete = false;
 
   /**
    * The contents of the source.
    */
   String _content;
 
   /**
    * The time at which the contents of the source were last modified.
    */
   int _modificationTime = -1;
 
   /**
    * Initialize a newly created task to perform analysis within the given context.
    *
    * @param context the context in which the task is to be performed
    * @param source the source to be parsed
    * @param contentData the time-stamped contents of the source
    */
-  GetContentTask(InternalAnalysisContext context, Source source) : super(context) {
+  GetContentTask(InternalAnalysisContext context, this.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.
    */
-  IncrementalAnalysisCache cache;
+  final 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, IncrementalAnalysisCache cache) : super(context) {
-    this.cache = cache;
-  }
+  IncrementalAnalysisTask(InternalAnalysisContext context, this.cache) : super(context);
 
   @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 56 matching lines @@
       return null;
     }
   }
 }
 
 /**
  * Instances of the class `ParseDartTask` parse a specific source as a Dart file.
  */
 class ParseDartTask extends AnalysisTask {
   /**
+   * 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 context the context in which the resolution is to be performed
+   * @param librarySource the source representing the library containing the directive
+   * @param directive the directive which URI should be resolved
+   * @param errorListener the error listener to which errors should be reported
+   * @return the result of resolving the URI against the URI of the library
+   */
+  static Source resolveSource(AnalysisContext analysisContext, Source librarySource, UriBasedDirective directive, AnalysisErrorListener errorListener) {
+    StringLiteral uriLiteral = directive.uri;
+    if (uriLiteral is StringInterpolation) {
+      errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.URI_WITH_INTERPOLATION, []));
+      return null;
+    }
+    String uriContent = uriLiteral.stringValue.trim();
+    directive.uriContent = uriContent;
+    if (directive is ImportDirective && uriContent.startsWith(_DART_EXT_SCHEME)) {
+      return null;
+    }
+    try {
+      String encodedUriContent = Uri.encodeFull(uriContent);
+      parseUriWithException(encodedUriContent);
+      Source source = analysisContext.sourceFactory.resolveUri(librarySource, encodedUriContent);
+      if (!analysisContext.exists(source)) {
+        errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.URI_DOES_NOT_EXIST, [uriContent]));
+      }
+      directive.source = source;
+      return source;
+    } on URISyntaxException catch (exception) {
+      errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.INVALID_URI, [uriContent]));
+    }
+    return null;
+  }
+
+  /**
    * The source to be parsed.
    */
-  Source source;
+  final Source source;
 
   /**
    * The time at which the contents of the source were last modified.
    */
-  int modificationTime = 0;
+  final int modificationTime;
 
   /**
    * The head of the token stream used for parsing.
    */
-  Token _tokenStream;
+  final Token _tokenStream;
 
   /**
    * The line information associated with the source.
    */
-  LineInfo lineInfo;
+  final 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, Source source, int modificationTime, Token tokenStream, LineInfo lineInfo) : super(context) {
-    this.source = source;
-    this.modificationTime = modificationTime;
-    this._tokenStream = tokenStream;
-    this.lineInfo = lineInfo;
-  }
+  ParseDartTask(InternalAnalysisContext context, this.source, this.modificationTime, this._tokenStream, this.lineInfo) : super(context);
 
   @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 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, or
+   * `false` if the task has not yet been performed or if an exception occurred.
    *
-   * @return `true` if the source contains a 'library' directive
+   * @return `true` if the source contains any directive other than a 'part of' directive
    */
-  bool get hasLibraryDirective => _containsLibraryDirective;
+  bool get hasNonPartOfDirective => _containsNonPartOfDirective;
 
   /**
    * 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);
+      AnalysisContext analysisContext = context;
       for (Directive directive in _unit.directives) {
-        if (directive is ExportDirective) {
-          Source exportSource = _resolveSource(source, directive, errorListener);
-          if (exportSource != null) {
-            _exportedSources.add(exportSource);
+        if (directive is PartOfDirective) {
+          _containsPartOfDirective = true;
+        } else {
+          _containsNonPartOfDirective = true;
+          if (directive is ExportDirective) {
+            Source exportSource = resolveSource(analysisContext, source, directive, errorListener);
+            if (exportSource != null) {
+              _exportedSources.add(exportSource);
+            }
+          } else if (directive is ImportDirective) {
+            Source importSource = resolveSource(analysisContext, source, directive, errorListener);
+            if (importSource != null) {
+              _importedSources.add(importSource);
+            }
+          } else if (directive is PartDirective) {
+            Source partSource = resolveSource(analysisContext, source, directive, errorListener);
+            if (partSource != null && partSource != source) {
+              _includedSources.add(partSource);
+            }
           }
-        } 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;
         }
       }
+      _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
-   * @param directive the directive which URI should be resolved
-   * @param errorListener the error listener to which errors should be reported
-   * @return the result of resolving the URI against the URI of the library
-   */
-  Source _resolveSource(Source librarySource, UriBasedDirective directive, AnalysisErrorListener errorListener) {
-    StringLiteral uriLiteral = directive.uri;
-    if (uriLiteral is StringInterpolation) {
-      errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.URI_WITH_INTERPOLATION, []));
-      return null;
-    }
-    String uriContent = uriLiteral.stringValue.trim();
-    directive.uriContent = uriContent;
-    if (directive is ImportDirective && uriContent.startsWith(_DART_EXT_SCHEME)) {
-      return null;
-    }
-    try {
-      String encodedUriContent = Uri.encodeFull(uriContent);
-      parseUriWithException(encodedUriContent);
-      AnalysisContext analysisContext = context;
-      Source source = analysisContext.sourceFactory.resolveUri(librarySource, encodedUriContent);
-      if (!analysisContext.exists(source)) {
-        errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.URI_DOES_NOT_EXIST, [uriContent]));
-      }
-      directive.source = source;
-      return source;
-    } on URISyntaxException catch (exception) {
-      errorListener.onError(new AnalysisError.con2(librarySource, uriLiteral.offset, uriLiteral.length, CompileTimeErrorCode.INVALID_URI, [uriContent]));
-    }
-    return null;
-  }
-
-  /**
    * Efficiently convert the given set of sources to an array.
    *
    * @param sources the set to be converted
    * @return an array containing all of the sources in the given set
    */
   List<Source> _toArray(Set<Source> sources) {
     int size = sources.length;
     if (size == 0) {
       return Source.EMPTY_ARRAY;
     }
     return new List.from(sources);
   }
 }
 
 /**
  * Instances of the class `ParseHtmlTask` parse a specific source as an HTML file.
  */
 class ParseHtmlTask extends AnalysisTask {
   /**
    * The source to be parsed.
    */
-  Source source;
+  final Source source;
 
   /**
    * The time at which the contents of the source were last modified.
    */
-  int modificationTime = 0;
+  final int modificationTime;
 
   /**
    * The contents of the source.
    */
-  String _content;
+  final 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, Source source, int modificationTime, String content) : super(context) {
-    this.source = source;
-    this.modificationTime = modificationTime;
-    this._content = content;
-  }
+  ParseHtmlTask(InternalAnalysisContext context, this.source, this.modificationTime, this._content) : super(context);
 
   @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 31 matching lines @@
 
   @override
   void internalPerform() {
     try {
       ht.AbstractScanner scanner = new ht.StringScanner(source, _content);
       scanner.passThroughElements = <String> [_TAG_SCRIPT];
       ht.Token token = scanner.tokenize();
       _lineInfo = new LineInfo(scanner.lineStarts);
       RecordingErrorListener errorListener = new RecordingErrorListener();
       _unit = new ht.HtmlParser(source, errorListener).parse(token, _lineInfo);
+      _unit.accept(new RecursiveXmlVisitor_ParseHtmlTask_internalPerform(this, errorListener));
       _errors = errorListener.getErrorsForSource(source);
       _referencedLibraries = librarySources;
     } on JavaException catch (exception) {
       throw new AnalysisException.con3(exception);
     }
   }
 
   /**
    * Return the sources of libraries that are referenced in the specified HTML file.
    *
    * @return the sources of libraries that are referenced in the HTML file
    */
   List<Source> get librarySources {
     List<Source> libraries = new List<Source>();
     _unit.accept(new RecursiveXmlVisitor_ParseHtmlTask_getLibrarySources(this, libraries));
     if (libraries.isEmpty) {
       return Source.EMPTY_ARRAY;
     }
     return new List.from(libraries);
   }
+
+  /**
+   * Resolves directives in the given [CompilationUnit].
+   */
+  void _resolveScriptDirectives(CompilationUnit script, AnalysisErrorListener errorListener) {
+    if (script == null) {
+      return;
+    }
+    AnalysisContext analysisContext = context;
+    for (Directive directive in script.directives) {
+      if (directive is ExportDirective) {
+        ParseDartTask.resolveSource(analysisContext, source, directive, errorListener);
+      } else if (directive is ImportDirective) {
+        ParseDartTask.resolveSource(analysisContext, source, directive, errorListener);
+      } else if (directive is PartDirective) {
+        ParseDartTask.resolveSource(analysisContext, source, directive, errorListener);
+      }
+    }
+  }
+}
+
+class RecursiveXmlVisitor_ParseHtmlTask_internalPerform extends ht.RecursiveXmlVisitor<Object> {
+  final ParseHtmlTask ParseHtmlTask_this;
+
+  RecordingErrorListener errorListener;
+
+  RecursiveXmlVisitor_ParseHtmlTask_internalPerform(this.ParseHtmlTask_this, this.errorListener) : super();
+
+  @override
+  Object visitHtmlScriptTagNode(ht.HtmlScriptTagNode node) {
+    ParseHtmlTask_this._resolveScriptDirectives(node.script, errorListener);
+    return null;
+  }
 }
 
 class RecursiveXmlVisitor_ParseHtmlTask_getLibrarySources extends ht.RecursiveXmlVisitor<Object> {
   final ParseHtmlTask ParseHtmlTask_this;
 
   List<Source> libraries;
 
   RecursiveXmlVisitor_ParseHtmlTask_getLibrarySources(this.ParseHtmlTask_this, this.libraries) : super();
 
   @override
@@ skipping 20 matching lines @@
 }
 
 /**
  * Instances of the class `ResolveAngularComponentTemplateTask` resolve HTML template
  * referenced by [AngularComponentElement].
  */
 class ResolveAngularComponentTemplateTask extends AnalysisTask {
   /**
    * The source to be resolved.
    */
-  Source source;
+  final Source source;
 
   /**
    * The time at which the contents of the source were last modified.
    */
-  int modificationTime = 0;
+  final int modificationTime;
 
   /**
    * The HTML unit to be resolved.
    */
-  ht.HtmlUnit _unit;
+  final ht.HtmlUnit _unit;
 
   /**
    * The [AngularComponentElement] to resolve template for.
    */
-  AngularComponentElement _component;
+  final AngularComponentElement _component;
 
   /**
    * The Angular application to resolve in context of.
    */
-  AngularApplication _application;
+  final 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, 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;
-  }
+  ResolveAngularComponentTemplateTask(InternalAnalysisContext context, this.source, this.modificationTime, this._unit, this._component, this._application) : super(context);
 
   @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.
    */
-  Source source;
+  final Source source;
 
   /**
    * The time at which the contents of the source were last modified.
    */
-  int modificationTime = 0;
+  final int modificationTime;
 
   /**
    * The HTML unit to be resolved.
    */
-  ht.HtmlUnit _unit;
+  final 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, Source source, int modificationTime, ht.HtmlUnit unit) : super(context) {
-    this.source = source;
-    this.modificationTime = modificationTime;
-    this._unit = unit;
-  }
+  ResolveAngularEntryHtmlTask(InternalAnalysisContext context, this.source, this.modificationTime, this._unit) : super(context);
 
   @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.
    */
-  Source unitSource;
+  final Source unitSource;
 
   /**
    * The source representing the library to be resolved.
    */
-  Source librarySource;
+  final Source librarySource;
 
   /**
    * The libraries that are part of the cycle containing the library to be resolved.
    */
-  List<ResolvableLibrary> _librariesInCycle;
+  final 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, Source unitSource, Source librarySource, List<ResolvableLibrary> librariesInCycle) : super(context) {
-    this.unitSource = unitSource;
-    this.librarySource = librarySource;
-    this._librariesInCycle = librariesInCycle;
-  }
+  ResolveDartLibraryCycleTask(InternalAnalysisContext context, this.unitSource, this.librarySource, this._librariesInCycle) : super(context);
 
   @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.
    */
-  Source unitSource;
+  final Source unitSource;
 
   /**
    * The source representing the library to be resolved.
    */
-  Source librarySource;
+  final 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, Source unitSource, Source librarySource) : super(context) {
-    this.unitSource = unitSource;
-    this.librarySource = librarySource;
-  }
+  ResolveDartLibraryTask(InternalAnalysisContext context, this.unitSource, this.librarySource) : super(context);
 
   @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.
    */
-  Source source;
+  final Source source;
 
   /**
    * The element model for the library containing the source.
    */
-  LibraryElement _libraryElement;
+  final 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, Source source, LibraryElement libraryElement) : super(context) {
-    this.source = source;
-    this._libraryElement = libraryElement;
-  }
+  ResolveDartUnitTask(InternalAnalysisContext context, this.source, this._libraryElement) : super(context);
 
   @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.
    */
-  Source source;
+  final Source source;
 
   /**
    * The time at which the contents of the source were last modified.
    */
-  int modificationTime = 0;
+  final int modificationTime;
 
   /**
    * The HTML unit to be resolved.
    */
-  ht.HtmlUnit _unit;
+  final 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, Source source, int modificationTime, ht.HtmlUnit unit) : super(context) {
-    this.source = source;
-    this.modificationTime = modificationTime;
-    this._unit = unit;
-  }
+  ResolveHtmlTask(InternalAnalysisContext context, this.source, this.modificationTime, this._unit) : super(context);
 
   @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.
    */
-  Source source;
+  final Source source;
 
   /**
    * The time at which the contents of the source were last modified.
    */
-  int modificationTime = 0;
+  final int modificationTime;
 
   /**
    * The contents of the source.
    */
-  String _content;
+  final 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, Source source, int modificationTime, String content) : super(context) {
-    this.source = source;
-    this.modificationTime = modificationTime;
-    this._content = content;
-  }
+  ScanDartTask(InternalAnalysisContext context, this.source, this.modificationTime, this._content) : super(context);
 
   @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) {
   }
 }