New analyzer snapshot.

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

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine;
 
 import 'java_core.dart';
@@ skipping 69 matching lines @@
     String extension = FileNameUtilities.getExtension(fileName);
     return javaStringEqualsIgnoreCase(extension, SUFFIX_HTML) || javaStringEqualsIgnoreCase(extension, SUFFIX_HTM);
   }
 
   /**
    * The logger that should receive information about errors within the analysis engine.
    */
   Logger _logger = Logger.NULL;
 
   /**
+   * The partition manager being used to manage the shared partitions.
+   */
+  final PartitionManager partitionManager = new PartitionManager();
+
+  /**
    * Create a new context in which analysis can be performed.
    *
    * @return the analysis context that was created
    */
   AnalysisContext createAnalysisContext() {
     //
     // If instrumentation is ignoring data, return an uninstrumented analysis context.
     //
     if (Instrumentation.isNullLogger) {
-      return new DelegatingAnalysisContextImpl();
+      return new AnalysisContextImpl();
     }
-    return new InstrumentedAnalysisContextImpl.con1(new DelegatingAnalysisContextImpl());
+    return new InstrumentedAnalysisContextImpl.con1(new AnalysisContextImpl());
   }
 
   /**
    * Return the logger that should receive information about errors within the analysis engine.
    *
    * @return the logger that should receive information about errors within the analysis engine
    */
   Logger get logger => _logger;
 
   /**
@@ skipping 840 matching lines @@
 
   /**
    * Return the source for which the result is being reported.
    *
    * @return the source for which the result is being reported
    */
   Source get source;
 }
 
 /**
- * Instances of the class `ChangeSet` indicate what sources have been added, changed, or
- * removed.
+ * Instances of the class `ChangeSet` indicate which sources have been added, changed,
+ * removed, or deleted. In the case of a changed source, there are multiple ways of indicating the
+ * nature of the change.
+ *
+ * No source should be added to the change set more than once, either with the same or a different
+ * kind of change. It does not make sense, for example, for a source to be both added and removed,
+ * and it is redundant for a source to be marked as changed in its entirety and changed in some
+ * specific range.
  */
 class ChangeSet {
   /**
    * A list containing the sources that have been added.
    */
-  List<Source> _added = new List<Source>();
+  final List<Source> addedSources = new List<Source>();
 
   /**
    * A list containing the sources that have been changed.
    */
-  List<Source> _changed = new List<Source>();
+  final List<Source> changedSources = new List<Source>();
+
+  /**
+   * A table mapping the sources whose content has been changed to the current content of those
+   * sources.
+   */
+  Map<Source, String> _changedContent = new Map<Source, String>();
+
+  /**
+   * A table mapping the sources whose content has been changed within a single range to the current
+   * content of those sources and information about the affected range.
+   */
+  final Map<Source, ChangeSet_ContentChange> changedRanges = new Map<Source, ChangeSet_ContentChange>();
 
   /**
    * A list containing the sources that have been removed.
    */
-  List<Source> _removed = new List<Source>();
+  final List<Source> removedSources = new List<Source>();
 
   /**
    * A list containing the source containers specifying additional sources that have been removed.
    */
   final List<SourceContainer> removedContainers = new List<SourceContainer>();
 
   /**
-   * Record that the specified source has been added and that it's content is the default contents
-   * of the source.
+   * A list containing the sources that have been deleted.
+   */
+  final List<Source> deletedSources = new List<Source>();
+
+  /**
+   * Record that the specified source has been added and that its content is the default contents of
+   * the source.
    *
    * @param source the source that was added
    */
   void addedSource(Source source) {
-    _added.add(source);
+    addedSources.add(source);
   }
 
   /**
-   * Record that the specified source has been changed and that it's content is the default contents
-   * of the source.
+   * Record that the specified source has been changed and that its content is the given contents.
+   *
+   * @param source the source that was changed
+   * @param contents the new contents of the source, or `null` if the default contents of the
+   *          source are to be used
+   */
+  void changedContent(Source source, String contents) {
+    _changedContent[source] = contents;
+  }
+
+  /**
+   * Record that the specified source has been changed and that its content is the given contents.
+   *
+   * @param source the source that was changed
+   * @param contents the new contents of the source
+   * @param offset the offset into the current contents
+   * @param oldLength the number of characters in the original contents that were replaced
+   * @param newLength the number of characters in the replacement text
+   */
+  void changedRange(Source source, String contents, int offset, int oldLength, int newLength) {
+    changedRanges[source] = new ChangeSet_ContentChange(contents, offset, oldLength, newLength);
+  }
+
+  /**
+   * Record that the specified source has been changed. If the content of the source was previously
+   * overridden, use [changedContent] instead.
    *
    * @param source the source that was changed
    */
   void changedSource(Source source) {
-    _changed.add(source);
+    changedSources.add(source);
   }
 
   /**
-   * Return a collection of the sources that have been added.
+   * Record that the specified source has been deleted.
    *
-   * @return a collection of the sources that have been added
+   * @param source the source that was deleted
    */
-  List<Source> get addedSources => _added;
+  void deletedSource(Source source) {
+    deletedSources.add(source);
+  }
 
   /**
-   * Return a collection of sources that have been changed.
+   * Return a table mapping the sources whose content has been changed to the current content of
+   * those sources.
    *
-   * @return a collection of sources that have been changed
+   * @return a table mapping the sources whose content has been changed to the current content of
+   *         those sources
    */
-  List<Source> get changedSources => _changed;
-
-  /**
-   * Return a list containing the sources that were removed.
-   *
-   * @return a list containing the sources that were removed
-   */
-  List<Source> get removedSources => _removed;
+  Map<Source, String> get changedContents => _changedContent;
 
   /**
    * Return `true` if this change set does not contain any changes.
    *
    * @return `true` if this change set does not contain any changes
    */
-  bool get isEmpty => _added.isEmpty && _changed.isEmpty && _removed.isEmpty && removedContainers.isEmpty;
+  bool get isEmpty => addedSources.isEmpty && changedSources.isEmpty && _changedContent.isEmpty && changedRanges.isEmpty && removedSources.isEmpty && removedContainers.isEmpty && deletedSources.isEmpty;
 
   /**
    * Record that the specified source container has been removed.
    *
    * @param container the source container that was removed
    */
   void removedContainer(SourceContainer container) {
     if (container != null) {
       removedContainers.add(container);
     }
   }
 
   /**
    * Record that the specified source has been removed.
    *
    * @param source the source that was removed
    */
   void removedSource(Source source) {
     if (source != null) {
-      _removed.add(source);
+      removedSources.add(source);
     }
   }
 
   @override
   String toString() {
     JavaStringBuilder builder = new JavaStringBuilder();
-    bool needsSeparator = _appendSources(builder, _added, false, "added");
-    needsSeparator = _appendSources(builder, _changed, needsSeparator, "changed");
-    _appendSources(builder, _removed, needsSeparator, "removed");
+    bool needsSeparator = _appendSources(builder, addedSources, false, "addedSources");
+    needsSeparator = _appendSources(builder, changedSources, needsSeparator, "changedSources");
+    needsSeparator = _appendSources2(builder, _changedContent, needsSeparator, "changedContent");
+    needsSeparator = _appendSources2(builder, changedRanges, needsSeparator, "changedRanges");
+    needsSeparator = _appendSources(builder, deletedSources, needsSeparator, "deletedSources");
+    needsSeparator = _appendSources(builder, removedSources, needsSeparator, "removedSources");
     int count = removedContainers.length;
     if (count > 0) {
-      if (_removed.isEmpty) {
+      if (removedSources.isEmpty) {
         if (needsSeparator) {
           builder.append("; ");
         }
         builder.append("removed: from ");
         builder.append(count);
         builder.append(" containers");
       } else {
         builder.append(", and more from ");
         builder.append(count);
         builder.append(" containers");
@@ skipping 21 matching lines @@
     }
     builder.append(label);
     String prefix = " ";
     for (Source source in sources) {
       builder.append(prefix);
       builder.append(source.fullName);
       prefix = ", ";
     }
     return true;
   }
+
+  /**
+   * Append the given sources to the given builder, prefixed with the given label and possibly a
+   * separator.
+   *
+   * @param builder the builder to which the sources are to be appended
+   * @param sources the sources to be appended
+   * @param needsSeparator `true` if a separator is needed before the label
+   * @param label the label used to prefix the sources
+   * @return `true` if future lists of sources will need a separator
+   */
+  bool _appendSources2(JavaStringBuilder builder, Map<Source, dynamic> sources, bool needsSeparator, String label) {
+    if (sources.isEmpty) {
+      return needsSeparator;
+    }
+    if (needsSeparator) {
+      builder.append("; ");
+    }
+    builder.append(label);
+    String prefix = " ";
+    for (Source source in sources.keys.toSet()) {
+      builder.append(prefix);
+      builder.append(source.fullName);
+      prefix = ", ";
+    }
+    return true;
+  }
 }
 
 /**
+ * Instances of the class `ContentChange` represent a change to the content of a source.
+ */
+class ChangeSet_ContentChange {
+  /**
+   * The new contents of the source.
+   */
+  final String contents;
+
+  /**
+   * The offset into the current contents.
+   */
+  final int offset;
+
+  /**
+   * The number of characters in the original contents that were replaced
+   */
+  final int oldLength;
+
+  /**
+   * The number of characters in the replacement text.
+   */
+  final int newLength;
+
+  /**
+   * Initialize a newly created change object to represent a change to the content of a source.
+   *
+   * @param contents the new contents of the source
+   * @param offset the offset into the current contents
+   * @param oldLength the number of characters in the original contents that were replaced
+   * @param newLength the number of characters in the replacement text
+   */
+  ChangeSet_ContentChange(this.contents, this.offset, this.oldLength, this.newLength);
+}
+
+/**
  * Instances of the class `ObsoleteSourceAnalysisException` represent an analysis attempt that
  * failed because a source was deleted between the time the analysis started and the time the
  * results of the analysis were ready to be recorded.
  */
 class ObsoleteSourceAnalysisException extends AnalysisException {
   /**
    * The source that was removed while it was being analyzed.
    */
   Source _source;
 
@@ skipping 13 matching lines @@
    */
   Source get source => _source;
 }
 
 /**
  * Instances of the class `AnalysisCache` implement an LRU cache of information related to
  * analysis.
  */
 class AnalysisCache {
   /**
+   * An array containing the partitions of which this cache is comprised.
+   */
+  final List<CachePartition> _partitions;
+
+  /**
+   * Initialize a newly created cache to have the given partitions. The partitions will be searched
+   * in the order in which they appear in the array, so the most specific partition (usually an
+   * [SdkCachePartition]) should be first and the most general (usually a
+   * [UniversalCachePartition]) last.
+   *
+   * @param partitions the partitions for the newly created cache
+   */
+  AnalysisCache(this._partitions);
+
+  /**
+   * 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) {
+    int count = _partitions.length;
+    for (int i = 0; i < count; i++) {
+      if (_partitions[i].contains(source)) {
+        _partitions[i].accessedAst(source);
+        return;
+      }
+    }
+  }
+
+  /**
+   * Return the entry associated with the given source.
+   *
+   * @param source the source whose entry is to be returned
+   * @return the entry associated with the given source
+   */
+  SourceEntry get(Source source) {
+    int count = _partitions.length;
+    for (int i = 0; i < count; i++) {
+      if (_partitions[i].contains(source)) {
+        return _partitions[i].get(source);
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Return an iterator returning all of the map entries mapping sources to cache entries.
+   *
+   * @return an iterator returning all of the map entries mapping sources to cache entries
+   */
+  MapIterator<Source, SourceEntry> iterator() {
+    int count = _partitions.length;
+    List<Map<Source, SourceEntry>> maps = new List<Map>(count);
+    for (int i = 0; i < count; i++) {
+      maps[i] = _partitions[i].map;
+    }
+    return new MultipleMapIterator<Source, SourceEntry>(maps);
+  }
+
+  /**
+   * Associate the given entry with the given source.
+   *
+   * @param source the source with which the entry is to be associated
+   * @param entry the entry to be associated with the source
+   */
+  void put(Source source, SourceEntry entry) {
+    (entry as SourceEntryImpl).fixExceptionState();
+    int count = _partitions.length;
+    for (int i = 0; i < count; i++) {
+      if (_partitions[i].contains(source)) {
+        _partitions[i].put(source, entry);
+        return;
+      }
+    }
+  }
+
+  /**
+   * Remove all information related to the given source from this cache.
+   *
+   * @param source the source to be removed
+   */
+  void remove(Source source) {
+    int count = _partitions.length;
+    for (int i = 0; i < count; i++) {
+      if (_partitions[i].contains(source)) {
+        _partitions[i].remove(source);
+        return;
+      }
+    }
+  }
+
+  /**
+   * Record that the AST associated with the given source was just removed from the cache.
+   *
+   * @param source the source whose AST was removed
+   */
+  void removedAst(Source source) {
+    int count = _partitions.length;
+    for (int i = 0; i < count; i++) {
+      if (_partitions[i].contains(source)) {
+        _partitions[i].removedAst(source);
+        return;
+      }
+    }
+  }
+
+  /**
+   * Return the number of sources that are mapped to cache entries.
+   *
+   * @return the number of sources that are mapped to cache entries
+   */
+  int size() {
+    int size = 0;
+    int count = _partitions.length;
+    for (int i = 0; i < count; i++) {
+      size += _partitions[i].size();
+    }
+    return size;
+  }
+
+  /**
+   * Record that the AST associated with the given source was just stored to the cache.
+   *
+   * @param source the source whose AST was stored
+   */
+  void storedAst(Source source) {
+    int count = _partitions.length;
+    for (int i = 0; i < count; i++) {
+      if (_partitions[i].contains(source)) {
+        _partitions[i].storedAst(source);
+        return;
+      }
+    }
+  }
+}
+
+/**
+ * Instances of the class `CachePartition` implement a single partition in an LRU cache of
+ * information related to analysis.
+ */
+abstract class CachePartition {
+  /**
    * A table mapping the sources known to the context to the information known about the source.
    */
   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;
 
   /**
@@ skipping 10 matching lines @@
 
   /**
    * Initialize a newly created cache to maintain at most the given number of AST structures in the
    * cache.
    *
    * @param maxCacheSize the maximum number of sources for which AST structures should be kept in
    *          the cache
    * @param retentionPolicy the policy used to determine which pieces of data to remove from the
    *          cache
    */
-  AnalysisCache(int maxCacheSize, this._retentionPolicy) {
+  CachePartition(int maxCacheSize, this._retentionPolicy) {
     this._maxCacheSize = maxCacheSize;
     _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)) {
       _recentlyUsed.add(source);
       return;
     }
     while (_recentlyUsed.length >= _maxCacheSize) {
       if (!_flushAstFromCache()) {
         break;
       }
     }
     _recentlyUsed.add(source);
   }
 
   /**
+   * Return `true` if the given source is contained in this partition.
+   *
+   * @param source the source being tested
+   * @return `true` if the source is contained in this partition
+   */
+  bool contains(Source source);
+
+  /**
    * Return the entry associated with the given source.
    *
    * @param source the source whose entry is to be returned
    * @return the entry associated with the given source
    */
   SourceEntry get(Source source) => _sourceMap[source];
 
   /**
+   * Return a table mapping the sources known to the context to the information known about the
+   * source.
+   *
+   * <b>Note:</b> This method is only visible for use by [AnalysisCache] and should not be
+   * used for any other purpose.
+   *
+   * @return a table mapping the sources known to the context to the information known about the
+   *         source
+   */
+  Map<Source, SourceEntry> get map => _sourceMap;
+
+  /**
    * Return an iterator returning all of the map entries mapping sources to cache entries.
    *
    * @return an iterator returning all of the map entries mapping sources to cache entries
    */
   MapIterator<Source, SourceEntry> iterator() => new SingleMapIterator<Source, SourceEntry>(_sourceMap);
 
   /**
    * Associate the given entry with the given source.
    *
    * @param source the source with which the entry is to be associated
@@ skipping 82 matching lines @@
       _sourceMap[removedSource] = dartCopy;
     }
     return true;
   }
 
   /**
    * Remove and return one source from the list of recently used sources whose AST structure can be
    * flushed from the cache. The source that will be returned will be the source that has been
    * unreferenced for the longest period of time but that is not a priority for analysis.
    *
-   * It is possible for there to be no AST that can be flushed, in which case `null` will be
-   * returned. This happens, for example, if the context is reserving the AST's needed to resolve a
-   * 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 (priority == RetentionPriority.LOW) {
         return _recentlyUsed.removeAt(i);
       } else if (priority == RetentionPriority.MEDIUM && sourceToRemove < 0) {
         sourceToRemove = i;
       }
     }
     if (sourceToRemove < 0) {
+      AnalysisEngine.instance.logger.logError2("Internal error: Could not flush data from the cache", new JavaException());
       return null;
     }
     return _recentlyUsed.removeAt(sourceToRemove);
   }
 }
 
 /**
  * Instances of the class `CacheRetentionPolicy` define the behavior of objects that determine
  * how important it is for data to be retained in the analysis cache.
  */
@@ skipping 1481 matching lines @@
    *
    * @param name the name of the descriptor
    */
   DataDescriptor(this._name);
 
   @override
   String toString() => _name;
 }
 
 /**
+ * Instances of the class `DefaultRetentionPolicy` implement a retention policy that will keep
+ * AST's in the cache if there is analysis information that needs to be computed for a source, where
+ * the computation is dependent on having the AST.
+ */
+class DefaultRetentionPolicy implements CacheRetentionPolicy {
+  /**
+   * An instance of this class that can be shared.
+   */
+  static DefaultRetentionPolicy POLICY = new DefaultRetentionPolicy();
+
+  @override
+  RetentionPriority getAstPriority(Source source, SourceEntry sourceEntry) {
+    if (sourceEntry is DartEntry) {
+      DartEntry dartEntry = sourceEntry;
+      if (astIsNeeded(dartEntry)) {
+        return RetentionPriority.MEDIUM;
+      }
+    }
+    return RetentionPriority.LOW;
+  }
+
+  /**
+   * Return `true` if there is analysis information in the given entry that needs to be
+   * computed, where the computation is dependent on having the AST.
+   *
+   * @param dartEntry the entry being tested
+   * @return `true` if there is analysis information that needs to be computed from the AST
+   */
+  bool astIsNeeded(DartEntry dartEntry) => dartEntry.hasInvalidData(DartEntry.HINTS) || dartEntry.hasInvalidData(DartEntry.VERIFICATION_ERRORS) || dartEntry.hasInvalidData(DartEntry.RESOLUTION_ERRORS);
+}
+
+/**
  * 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 {
   /**
    * The data descriptor representing the information about an Angular application this source is
    * used in.
    */
   static final DataDescriptor<AngularApplication> ANGULAR_APPLICATION = new DataDescriptor<AngularApplication>("HtmlEntry.ANGULAR_APPLICATION");
 
@@ skipping 583 matching lines @@
     builder.append("; angularErrors = ");
     builder.append(_angularErrorsState);
     builder.append("; polymerBuildErrors = ");
     builder.append(_polymerBuildErrorsState);
     builder.append("; polymerResolutionErrors = ");
     builder.append(_polymerResolutionErrorsState);
   }
 }
 
 /**
+ * Instances of the class `PartitionManager` manage the partitions that can be shared between
+ * analysis contexts.
+ */
+class PartitionManager {
+  /**
+   * A table mapping SDK's to the partitions used for those SDK's.
+   */
+  Map<DartSdk, SdkCachePartition> _sdkPartitions = new Map<DartSdk, SdkCachePartition>();
+
+  /**
+   * The default cache size for a Dart SDK partition.
+   */
+  static int _DEFAULT_SDK_CACHE_SIZE = 256;
+
+  /**
+   * Return the partition being used for the given SDK, creating the partition if necessary.
+   *
+   * @param sdk the SDK for which a partition is being requested
+   * @return the partition being used for the given SDK
+   */
+  SdkCachePartition forSdk(DartSdk sdk) {
+    SdkCachePartition partition = _sdkPartitions[sdk];
+    if (partition == null) {
+      partition = new SdkCachePartition(_DEFAULT_SDK_CACHE_SIZE);
+      _sdkPartitions[sdk] = partition;
+    }
+    return partition;
+  }
+}
+
+/**
  * The enumerated type `RetentionPriority` represents the priority of data in the cache in
  * terms of the desirability of retaining some specified data about a specified source.
  */
 class RetentionPriority extends Enum<RetentionPriority> {
   /**
    * A priority indicating that a given piece of data can be removed from the cache without
    * reservation.
    */
   static const RetentionPriority LOW = const RetentionPriority('LOW', 0);
 
   /**
    * A priority indicating that a given piece of data should not be removed from the cache unless
    * there are no sources for which the corresponding data has a lower priority. Currently used for
    * data that is needed in order to finish some outstanding analysis task.
    */
   static const RetentionPriority MEDIUM = const RetentionPriority('MEDIUM', 1);
 
   /**
    * A priority indicating that a given piece of data should not be removed from the cache.
    * Currently used for data related to a priority source.
    */
   static const RetentionPriority HIGH = const RetentionPriority('HIGH', 2);
 
   static const List<RetentionPriority> values = const [LOW, MEDIUM, HIGH];
 
   const RetentionPriority(String name, int ordinal) : super(name, ordinal);
 }
 
 /**
+ * Instances of the class `SdkCachePartition` implement a cache partition that contains all of
+ * the sources in the SDK.
+ */
+class SdkCachePartition extends CachePartition {
+  /**
+   * Initialize a newly created partition.
+   *
+   * @param maxCacheSize the maximum number of sources for which AST structures should be kept in
+   *          the cache
+   */
+  SdkCachePartition(int maxCacheSize) : super(maxCacheSize, DefaultRetentionPolicy.POLICY);
+
+  @override
+  bool contains(Source source) => source.isInSystemLibrary;
+}
+
+/**
  * 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.
    */
@@ skipping 158 matching lines @@
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
 
   /**
    * Invalidate all of the information associated with this source.
    */
   void invalidateAllInformation() {
     _content = null;
-    _contentState = CacheState.INVALID;
+    _contentState = _checkContentState(CacheState.INVALID);
     _lineInfo = null;
     _lineInfoState = CacheState.INVALID;
   }
 
   /**
    * Record that an error occurred while attempting to get the contents of the source represented by
    * this entry. This will set the state of all information, including any resolution-based
    * information, as being in error.
    */
   void recordContentError() {
@@ skipping 22 matching lines @@
 
   /**
    * Set the state of the data represented by the given descriptor to the given state.
    *
    * @param descriptor the descriptor representing the data whose state is to be set
    * @param the new state of the data represented by the given descriptor
    */
   void setState(DataDescriptor descriptor, CacheState state) {
     if (identical(descriptor, SourceEntry.CONTENT)) {
       _content = updatedValue(state, _content, null);
-      _contentState = state;
+      _contentState = _checkContentState(state);
     } else if (identical(descriptor, SourceEntry.LINE_INFO)) {
       _lineInfo = updatedValue(state, _lineInfo, null);
       _lineInfoState = state;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
 
   /**
    * Set the value of the data represented by the given descriptor to the given value.
    *
    * @param descriptor the descriptor representing the data whose value is to be set
    * @param value the new value of the data represented by the given descriptor
    */
   void setValue(DataDescriptor descriptor, Object value) {
     if (identical(descriptor, SourceEntry.CONTENT)) {
       _content = value as String;
-      _contentState = CacheState.VALID;
+      _contentState = _checkContentState(CacheState.VALID);
     } else if (identical(descriptor, SourceEntry.LINE_INFO)) {
       _lineInfo = value as LineInfo;
       _lineInfoState = CacheState.VALID;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
 
   @override
   String toString() {
@@ skipping 81 matching lines @@
    * @param builder the builder to which the text should be written
    */
   void writeOn(JavaStringBuilder builder) {
     builder.append("time = ");
     builder.append(_modificationTime);
     builder.append("; content = ");
     builder.append(_contentState);
     builder.append("; lineInfo = ");
     builder.append(_lineInfoState);
   }
+
+  /**
+   * If the state is changing from ERROR to anything else, capture the information. This is an
+   * attempt to discover the underlying cause of a long-standing bug.
+   *
+   * @param newState the new state of the content
+   * @return the new state of the content
+   */
+  CacheState _checkContentState(CacheState newState) {
+    if (_contentState == CacheState.ERROR) {
+      InstrumentationBuilder builder = Instrumentation.builder2("SourceEntryImpl-checkContentState");
+      builder.data3("message", "contentState changing from ${_contentState} to ${newState}");
+      //builder.data("source", source.getFullName());
+      builder.record(new AnalysisException());
+      builder.log();
+    }
+    return newState;
+  }
 }
 
 /**
+ * Instances of the class `UniversalCachePartition` implement a cache partition that contains
+ * all sources not contained in other partitions.
+ */
+class UniversalCachePartition extends CachePartition {
+  /**
+   * Initialize a newly created partition.
+   *
+   * @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
+   */
+  UniversalCachePartition(int maxCacheSize, CacheRetentionPolicy retentionPolicy) : super(maxCacheSize, retentionPolicy);
+
+  @override
+  bool contains(Source source) => true;
+}
+
+/**
  * Implementation of the [AnalysisContentStatistics].
  */
 class AnalysisContentStatisticsImpl implements AnalysisContentStatistics {
   Map<String, AnalysisContentStatistics_CacheRow> _dataMap = new Map<String, AnalysisContentStatistics_CacheRow>();
 
   List<Source> _sources = new List<Source>();
 
   Set<AnalysisException> _exceptions = new Set<AnalysisException>();
 
   void addSource(Source source) {
@@ skipping 135 matching lines @@
    * The source factory used to create the sources that can be analyzed in this context.
    */
   SourceFactory _sourceFactory;
 
   /**
    * A source representing the core library.
    */
   Source _coreLibrarySource;
 
   /**
+   * The partition that contains analysis results that are not shared with other contexts.
+   */
+  CachePartition _privatePartition;
+
+  /**
    * A table mapping the sources known to the context to the information known about the source.
    */
   AnalysisCache _cache;
 
   /**
    * An array containing sources for which data should not be flushed.
    */
   List<Source> _priorityOrder = Source.EMPTY_ARRAY;
 
   /**
@@ skipping 15 matching lines @@
   Set<String> _recentTasks = new Set<String>();
 
   /**
    * The object used to synchronize access to all of the caches. The rules related to the use of
    * this lock object are
    * * no analysis work is done while holding the lock, and
    * * no analysis results can be recorded unless we have obtained the lock and validated that the
    * results are for the same version (modification time) of the source as our current cache
    * content.
    */
-  Object _cacheLock = new Object();
+  static Object _cacheLock = new Object();
 
   /**
    * The object used to record the results of performing an analysis task.
    */
   AnalysisContextImpl_AnalysisTaskResultRecorder _resultRecorder;
 
   /**
    * Cached information used in incremental analysis or `null` if none. Synchronize against
    * [cacheLock] before accessing this field.
    */
   IncrementalAnalysisCache _incrementalAnalysisCache;
 
   /**
    * The object used to manage the list of sources that need to be analyzed.
    */
   WorkManager _workManager = new WorkManager();
 
   /**
    * The set of [AngularApplication] in this context.
    */
   Set<AngularApplication> _angularApplications = new Set();
 
   /**
    * Initialize a newly created analysis context.
    */
   AnalysisContextImpl() : super() {
     _resultRecorder = new AnalysisContextImpl_AnalysisTaskResultRecorder(this);
-    _cache = new AnalysisCache(AnalysisOptionsImpl.DEFAULT_CACHE_SIZE, new AnalysisContextImpl_ContextRetentionPolicy(this));
+    _privatePartition = new UniversalCachePartition(AnalysisOptionsImpl.DEFAULT_CACHE_SIZE, new AnalysisContextImpl_ContextRetentionPolicy(this));
+    _cache = _createCacheFromSourceFactory(null);
   }
 
   @override
   void addSourceInfo(Source source, SourceEntry info) {
     // This implementation assumes that the access to the cache does not need to be synchronized
     // because no other object can have access to this context while this method is being invoked.
     _cache.put(source, info);
   }
 
   @override
@@ skipping 14 matching lines @@
     //
     bool addedDartSource = false;
     for (Source source in changeSet.addedSources) {
       if (_sourceAvailable(source)) {
         addedDartSource = true;
       }
     }
     for (Source source in changeSet.changedSources) {
       _sourceChanged(source);
     }
+    for (MapEntry<Source, String> entry in getMapEntrySet(changeSet.changedContents)) {
+      setContents(entry.getKey(), entry.getValue());
+    }
+    for (MapEntry<Source, ChangeSet_ContentChange> entry in getMapEntrySet(changeSet.changedRanges)) {
+      ChangeSet_ContentChange change = entry.getValue();
+      setChangedContents(entry.getKey(), change.contents, change.offset, change.oldLength, change.newLength);
+    }
+    for (Source source in changeSet.deletedSources) {
+      _sourceDeleted(source);
+    }
     for (Source source in removedSources) {
       _sourceRemoved(source);
     }
     if (addedDartSource) {
       // TODO(brianwilkerson) This is hugely inefficient, but we need to re-analyze any libraries
       // that might have been referencing the not-yet-existing source that was just added. Longer
       // term we need to keep track of which libraries are referencing non-existing sources and
       // only re-analyze those libraries.
       //        logInformation("Added Dart sources, invalidating all resolution information");
       List<Source> sourcesToInvalidate = new List<Source>();
@@ skipping 679 matching lines @@
         AnalysisEngine.instance.logger.logError2("Internal error while performing the task: ${task}", exception);
       }
     }
     int performEnd = JavaSystem.currentTimeMillis();
     return new AnalysisResult(_getChangeNotices(false), getEnd - getStart, task.runtimeType.toString(), performEnd - performStart);
   }
 
   @override
   void recordLibraryElements(Map<Source, LibraryElement> elementMap) {
     Source htmlSource = _sourceFactory.forUri(DartSdk.DART_HTML);
-    for (MapIterator<Source, LibraryElement> iter = SingleMapIterator.forMap(elementMap); iter.moveNext();) {
-      Source librarySource = iter.key;
-      LibraryElement library = iter.value;
+    for (MapEntry<Source, LibraryElement> entry in getMapEntrySet(elementMap)) {
+      Source librarySource = entry.getKey();
+      LibraryElement library = entry.getValue();
       //
       // Cache the element in the library's info.
       //
       DartEntry dartEntry = _getReadableDartEntry(librarySource);
       if (dartEntry != null) {
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         _recordElementData(dartCopy, library, library.source, htmlSource);
+        dartCopy.setValue(DartEntry.SCAN_ERRORS, AnalysisError.NO_ERRORS);
+        dartCopy.setValue(DartEntry.PARSE_ERRORS, AnalysisError.NO_ERRORS);
+        dartCopy.setState(DartEntry.PARSED_UNIT, CacheState.FLUSHED);
+        dartCopy.setValueInLibrary(DartEntry.BUILD_ELEMENT_ERRORS, librarySource, AnalysisError.NO_ERRORS);
+        dartCopy.setValueInLibrary(DartEntry.RESOLUTION_ERRORS, librarySource, AnalysisError.NO_ERRORS);
+        dartCopy.setStateInLibrary(DartEntry.RESOLVED_UNIT, librarySource, CacheState.FLUSHED);
+        dartCopy.setValueInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource, AnalysisError.NO_ERRORS);
+        dartCopy.setValue(DartEntry.ANGULAR_ERRORS, AnalysisError.NO_ERRORS);
+        dartCopy.setValueInLibrary(DartEntry.HINTS, librarySource, AnalysisError.NO_ERRORS);
         _cache.put(librarySource, dartCopy);
       }
     }
   }
 
   @override
   CompilationUnit resolveCompilationUnit(Source unitSource, LibraryElement library) {
     if (library == null) {
       return null;
     }
     return resolveCompilationUnit2(unitSource, library.source);
   }
 
   @override
   CompilationUnit resolveCompilationUnit2(Source unitSource, Source librarySource) => _getDartResolutionData2(unitSource, librarySource, DartEntry.RESOLVED_UNIT, null);
 
   @override
   ht.HtmlUnit resolveHtmlUnit(Source htmlSource) {
     computeHtmlElement(htmlSource);
     return parseHtmlUnit(htmlSource);
   }
 
   @override
   void set analysisOptions(AnalysisOptions options) {
     bool needsRecompute = this._options.analyzeFunctionBodies != options.analyzeFunctionBodies || this._options.generateSdkErrors != options.generateSdkErrors || this._options.dart2jsHint != options.dart2jsHint || (this._options.hint && !options.hint) || this._options.preserveComments != options.preserveComments;
     int cacheSize = options.cacheSize;
     if (this._options.cacheSize != cacheSize) {
       this._options.cacheSize = cacheSize;
-      _cache.maxCacheSize = cacheSize;
+      //cache.setMaxCacheSize(cacheSize);
+      _privatePartition.maxCacheSize = cacheSize;
       //
       // Cap the size of the priority list to being less than the cache size. Failure to do so can
       // result in an infinite loop in performAnalysisTask() because re-caching one AST structure
       // can cause another priority source's AST structure to be flushed.
       //
       int maxPriorityOrderSize = cacheSize - _PRIORITY_ORDER_SIZE_DELTA;
       if (_priorityOrder.length > maxPriorityOrderSize) {
         List<Source> newPriorityOrder = new List<Source>(maxPriorityOrderSize);
         JavaSystem.arraycopy(_priorityOrder, 0, newPriorityOrder, 0, maxPriorityOrderSize);
         _priorityOrder = newPriorityOrder;
       }
     }
     this._options.analyzeFunctionBodies = options.analyzeFunctionBodies;
     this._options.generateSdkErrors = options.generateSdkErrors;
     this._options.dart2jsHint = options.dart2jsHint;
     this._options.hint = options.hint;
     this._options.incremental = options.incremental;
     this._options.preserveComments = options.preserveComments;
     _generateSdkErrors = options.generateSdkErrors;
     if (needsRecompute) {
-      _invalidateAllResolutionInformation();
+      _invalidateAllLocalResolutionInformation();
     }
   }
 
   @override
   void set analysisPriorityOrder(List<Source> sources) {
     if (sources == null || sources.isEmpty) {
       _priorityOrder = Source.EMPTY_ARRAY;
     } else {
       while (sources.remove(null)) {
       }
@@ skipping 65 matching lines @@
       return;
     } else if (factory.context != null) {
       throw new IllegalStateException("Source factories cannot be shared between contexts");
     }
     if (_sourceFactory != null) {
       _sourceFactory.context = null;
     }
     factory.context = this;
     _sourceFactory = factory;
     _coreLibrarySource = _sourceFactory.forUri(DartSdk.DART_CORE);
-    _invalidateAllResolutionInformation();
+    _cache = _createCacheFromSourceFactory(factory);
+    _invalidateAllLocalResolutionInformation();
   }
 
   /**
    * Record the results produced by performing a [ResolveDartLibraryCycleTask]. If the results
    * were computed from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
@@ skipping 502 matching lines @@
     //
     // Check to see whether we already have the information being requested.
     //
     CacheState state = dartEntry.getStateInLibrary(descriptor, librarySource);
     while (state != CacheState.ERROR && state != CacheState.VALID) {
       //
       // If not, compute the information. Unless the modification date of the source continues to
       // change, this loop will eventually terminate.
       //
       LibraryElement library = computeLibraryElement(librarySource);
-      dartEntry = new GenerateDartErrorsTask(this, unitSource, dartEntry.modificationTime, resolveCompilationUnit(unitSource, library), library).perform(_resultRecorder) as DartEntry;
+      CompilationUnit unit = resolveCompilationUnit(unitSource, library);
+      if (unit == null) {
+        throw new AnalysisException.con1("Could not resolve compilation unit ${unitSource.fullName} in ${librarySource.fullName}");
+      }
+      dartEntry = new GenerateDartErrorsTask(this, unitSource, dartEntry.modificationTime, unit, library).perform(_resultRecorder) as DartEntry;
       state = dartEntry.getStateInLibrary(descriptor, librarySource);
     }
     return dartEntry;
   }
 
   /**
    * Given a source for an HTML file, return a cache entry in which all of the data represented by
    * the state of the given descriptors is either [CacheState#VALID] or
    * [CacheState#ERROR]. This method assumes that the data can be produced by parsing the
    * source if it is not already cached.
@@ skipping 104 matching lines @@
   bool _containsAny(List<Source> sources, List<Source> targetSources) {
     for (Source targetSource in targetSources) {
       if (_contains(sources, targetSource)) {
         return true;
       }
     }
     return false;
   }
 
   /**
+   * Create an analysis cache based on the given source factory.
+   *
+   * @param factory the source factory containing the information needed to create the cache
+   * @return the cache that was created
+   */
+  AnalysisCache _createCacheFromSourceFactory(SourceFactory factory) {
+    if (factory == null) {
+      return new AnalysisCache(<CachePartition> [_privatePartition]);
+    }
+    DartSdk sdk = factory.dartSdk;
+    if (sdk == null) {
+      return new AnalysisCache(<CachePartition> [_privatePartition]);
+    }
+    return new AnalysisCache(<CachePartition> [
+        AnalysisEngine.instance.partitionManager.forSdk(sdk),
+        _privatePartition]);
+  }
+
+  /**
    * Create a [GenerateDartErrorsTask] for the given source, marking the verification errors
    * as being in-process. The compilation unit and the library can be the same if the compilation
    * unit is the defining compilation unit of the library.
    *
    * @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 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 = unitEntry.getValueInLibrary(DartEntry.RESOLVED_UNIT, librarySource);
+    if (unit == null) {
+      AnalysisEngine.instance.logger.logInformation2("Entry has VALID state for RESOLVED_UNIT but null value for ${unitSource.fullName} in ${librarySource.fullName}", new AnalysisException());
+      DartEntryImpl dartCopy = unitEntry.writableCopy;
+      dartCopy.recordResolutionError();
+      _cache.put(unitSource, dartCopy);
+      return new AnalysisContextImpl_TaskData(null, false);
+    }
     LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
     DartEntryImpl dartCopy = unitEntry.writableCopy;
     dartCopy.setStateInLibrary(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.IN_PROCESS);
     _cache.put(unitSource, dartCopy);
     return new AnalysisContextImpl_TaskData(new GenerateDartErrorsTask(this, unitSource, dartCopy.modificationTime, unit, libraryElement), false);
   }
 
   /**
    * Create a [GenerateDartHintsTask] for the given source, marking the hints as being
    * in-process.
@@ skipping 1013 matching lines @@
         }
       }
     }
   }
 
   /**
    * Invalidate all of the resolution results computed by this context.
    *
    * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
    */
-  void _invalidateAllResolutionInformation() {
+  void _invalidateAllLocalResolutionInformation() {
     Map<Source, List<Source>> oldPartMap = new Map<Source, List<Source>>();
-    MapIterator<Source, SourceEntry> iterator = _cache.iterator();
+    MapIterator<Source, SourceEntry> iterator = _privatePartition.iterator();
     while (iterator.moveNext()) {
       Source source = iterator.key;
       SourceEntry sourceEntry = iterator.value;
       if (sourceEntry is HtmlEntry) {
         HtmlEntryImpl htmlCopy = sourceEntry.writableCopy;
         htmlCopy.invalidateAllResolutionInformation();
         iterator.value = htmlCopy;
       } else if (sourceEntry is DartEntry) {
         DartEntry dartEntry = sourceEntry;
         oldPartMap[source] = dartEntry.getValue(DartEntry.INCLUDED_PARTS);
@@ skipping 412 matching lines @@
       }
       if (thrownException == null) {
         thrownException = new AnalysisException.con1("GenerateDartHintsTask returned a null hint map without throwing an exception: ${librarySource.fullName}");
       }
       DartEntryImpl dartCopy = (sourceEntry as DartEntry).writableCopy;
       dartCopy.setStateInLibrary(DartEntry.HINTS, librarySource, CacheState.ERROR);
       dartCopy.exception = thrownException;
       _cache.put(librarySource, dartCopy);
       throw thrownException;
     }
-    for (MapIterator<Source, TimestampedData<List<AnalysisError>>> iter = SingleMapIterator.forMap(hintMap); iter.moveNext();) {
-      Source unitSource = iter.key;
-      TimestampedData<List<AnalysisError>> results = iter.value;
+    for (MapEntry<Source, TimestampedData<List<AnalysisError>>> entry in getMapEntrySet(hintMap)) {
+      Source unitSource = entry.getKey();
+      TimestampedData<List<AnalysisError>> results = entry.getValue();
       SourceEntry sourceEntry = _cache.get(unitSource);
       if (sourceEntry is! DartEntry) {
         // This shouldn't be possible because we should never have performed the task if the source
         // didn't represent a Dart file, but check to be safe.
         throw new AnalysisException.con1("Internal error: attempting to parse non-Dart file as a Dart file: ${unitSource.fullName}");
       }
       DartEntry dartEntry = sourceEntry as DartEntry;
       if (unitSource == librarySource) {
         libraryEntry = dartEntry;
       }
@@ skipping 893 matching lines @@
 
   /**
    * 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 (MapIterator<Source, List<Source>> iter = SingleMapIterator.forMap(oldPartMap); iter.moveNext();) {
-      Source librarySource = iter.key;
-      List<Source> oldParts = iter.value;
+    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 {
@@ skipping 93 matching lines @@
       _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 _sourceDeleted(Source source) {
+    SourceEntry sourceEntry = _cache.get(source);
+    if (sourceEntry is HtmlEntry) {
+      HtmlEntryImpl htmlCopy = sourceEntry.writableCopy;
+      _invalidateAngularResolution(htmlCopy);
+      htmlCopy.recordContentError();
+      _cache.put(source, 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);
+      }
+      DartEntryImpl dartCopy = sourceEntry.writableCopy;
+      dartCopy.recordContentError();
+      _cache.put(source, dartCopy);
+    }
+    _workManager.remove(source);
+    _removeFromPriorityOrder(source);
+  }
+
+  /**
+   * <b>Note:</b> This method must only be invoked while we are synchronized on [cacheLock].
+   *
+   * @param source the source that has been removed
+   */
   void _sourceRemoved(Source source) {
     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)) {
@@ skipping 605 matching lines @@
     return pairs;
   }
 
   /**
    * Ensure that there is a resolvable compilation unit available for the given source.
    *
    * @param source the source for which a resolvable compilation unit must be available
    * @param dartEntry the entry associated with the source
    */
   void _ensureResolvableCompilationUnit(Source source, DartEntry dartEntry) {
-    if (!dartEntry.hasResolvableCompilationUnit) {
+    // The entry will be null if the source represents a non-Dart file.
+    if (dartEntry != null && !dartEntry.hasResolvableCompilationUnit) {
       if (_taskData == null) {
         _taskData = AnalysisContextImpl_this._createParseDartTask(source, dartEntry);
       }
     }
   }
 
   Set<Source> _gatherSources(List<CycleBuilder_LibraryPair> libraryData) {
     int libraryCount = libraryData.length;
     Set<Source> sources = new Set<Source>();
     for (int i = 0; i < libraryCount; i++) {
@@ skipping 259 matching lines @@
     if (lineInfo == null) {
       AnalysisEngine.instance.logger.logInformation2("No line info: ${source}", new JavaException());
     }
   }
 
   @override
   String toString() => "Changes for ${source.fullName}";
 }
 
 /**
- * Instances of the class `DelegatingAnalysisContextImpl` extend [AnalysisContextImpl
- ] to delegate sources to the appropriate analysis context. For instance, if the
- * source is in a system library then the analysis context from the [DartSdk] is used.
- */
-class DelegatingAnalysisContextImpl extends AnalysisContextImpl {
-  /**
-   * This references the [InternalAnalysisContext] held onto by the [DartSdk] which is
-   * used (instead of this [AnalysisContext]) for SDK sources. This field is set when
-   * #setSourceFactory(SourceFactory) is called, and references the analysis context in the
-   * [DartUriResolver] in the [SourceFactory], this analysis context assumes that there
-   * will be such a resolver.
-   */
-  InternalAnalysisContext _sdkAnalysisContext;
-
-  @override
-  void addSourceInfo(Source source, SourceEntry info) {
-    if (source.isInSystemLibrary) {
-      _sdkAnalysisContext.addSourceInfo(source, info);
-    } else {
-      super.addSourceInfo(source, info);
-    }
-  }
-
-  @override
-  List<AnalysisError> computeErrors(Source source) {
-    if (source.isInSystemLibrary) {
-      return _sdkAnalysisContext.computeErrors(source);
-    } else {
-      return super.computeErrors(source);
-    }
-  }
-
-  @override
-  List<Source> computeExportedLibraries(Source source) {
-    if (source.isInSystemLibrary) {
-      return _sdkAnalysisContext.computeExportedLibraries(source);
-    } else {
-      return super.computeExportedLibraries(source);
-    }
-  }
-
-  @override
-  HtmlElement computeHtmlElement(Source source) {
-    if (source.isInSystemLibrary) {
-      return _sdkAnalysisContext.computeHtmlElement(source);
-    } else {
-      return super.computeHtmlElement(source);
-    }
-  }
-
-  @override
-  List<Source> computeImportedLibraries(Source source) {
-    if (source.isInSystemLibrary) {
-      return _sdkAnalysisContext.computeImportedLibraries(source);
-    } else {
-      return super.computeImportedLibraries(source);
-    }
-  }
-
-  @override
-  SourceKind computeKindOf(Source source) {
-    if (source.isInSystemLibrary) {
-      return _sdkAnalysisContext.computeKindOf(source);
-    } else {
-      return super.computeKindOf(source);
-    }
-  }
-
-  @override
-  LibraryElement computeLibraryElement(Source source) {
-    if (source.isInSystemLibrary) {
-      return _sdkAnalysisContext.computeLibraryElement(source);
-    } else {
-      return super.computeLibraryElement(source);
-    }
-  }
-
-  @override
-  LineInfo computeLineInfo(Source source) {
-    if (source.isInSystemLibrary) {
-      return _sdkAnalysisContext.computeLineInfo(source);
-    } else {
-      return super.computeLineInfo(source);
-    }
-  }
-
-  @override
-  ResolvableCompilationUnit computeResolvableCompilationUnit(Source source) {
-    if (source.isInSystemLibrary) {
-      return _sdkAnalysisContext.computeResolvableCompilationUnit(source);
-    } else {
-      return super.computeResolvableCompilationUnit(source);
-    }
-  }
-
-  @override
-  AnalysisErrorInfo getErrors(Source source) {
-    if (source.isInSystemLibrary) {
-      return _sdkAnalysisContext.getErrors(source);
-    } else {
-      return super.getErrors(source);
-    }
-  }
-
-  @override
-  HtmlElement getHtmlElement(Source source) {
-    if (source.isInSystemLibrary) {
-      return _sdkAnalysisContext.getHtmlElement(source);
-    } else {
-      return super.getHtmlElement(source);
-    }
-  }
-
-  @override
-  List<Source> getHtmlFilesReferencing(Source source) {
-    if (source.isInSystemLibrary) {
-      return _sdkAnalysisContext.getHtmlFilesReferencing(source);
-    } else {
-      return super.getHtmlFilesReferencing(source);
-    }
-  }
-
-  @override
-  SourceKind getKindOf(Source source) {
-    if (source.isInSystemLibrary) {
-      return _sdkAnalysisContext.getKindOf(source);
-    } else {
-      return super.getKindOf(source);
-    }
-  }
-
-  @override
-  List<Source> getLibrariesContaining(Source source) {
-    if (source.isInSystemLibrary) {
-      return _sdkAnalysisContext.getLibrariesContaining(source);
-    } else {
-      return super.getLibrariesContaining(source);
-    }
-  }
-
-  @override
-  List<Source> getLibrariesDependingOn(Source librarySource) {
-    if (librarySource.isInSystemLibrary) {
-      return _sdkAnalysisContext.getLibrariesDependingOn(librarySource);
-    } else {
-      return super.getLibrariesDependingOn(librarySource);
-    }
-  }
-
-  @override
-  LibraryElement getLibraryElement(Source source) {
-    if (source.isInSystemLibrary) {
-      return _sdkAnalysisContext.getLibraryElement(source);
-    } else {
-      return super.getLibraryElement(source);
-    }
-  }
-
-  @override
-  List<Source> get librarySources => ArrayUtils.addAll(super.librarySources, _sdkAnalysisContext.librarySources);
-
-  @override
-  LineInfo getLineInfo(Source source) {
-    if (source.isInSystemLibrary) {
-      return _sdkAnalysisContext.getLineInfo(source);
-    } else {
-      return super.getLineInfo(source);
-    }
-  }
-
-  @override
-  Namespace getPublicNamespace(LibraryElement library) {
-    Source source = library.source;
-    if (source.isInSystemLibrary) {
-      return _sdkAnalysisContext.getPublicNamespace(library);
-    } else {
-      return super.getPublicNamespace(library);
-    }
-  }
-
-  @override
-  CompilationUnit getResolvedCompilationUnit(Source unitSource, LibraryElement library) {
-    if (unitSource.isInSystemLibrary) {
-      return _sdkAnalysisContext.getResolvedCompilationUnit(unitSource, library);
-    } else {
-      return super.getResolvedCompilationUnit(unitSource, library);
-    }
-  }
-
-  @override
-  CompilationUnit getResolvedCompilationUnit2(Source unitSource, Source librarySource) {
-    if (unitSource.isInSystemLibrary) {
-      return _sdkAnalysisContext.getResolvedCompilationUnit2(unitSource, librarySource);
-    } else {
-      return super.getResolvedCompilationUnit2(unitSource, librarySource);
-    }
-  }
-
-  @override
-  bool isClientLibrary(Source librarySource) {
-    if (librarySource.isInSystemLibrary) {
-      return _sdkAnalysisContext.isClientLibrary(librarySource);
-    } else {
-      return super.isClientLibrary(librarySource);
-    }
-  }
-
-  @override
-  bool isServerLibrary(Source librarySource) {
-    if (librarySource.isInSystemLibrary) {
-      return _sdkAnalysisContext.isServerLibrary(librarySource);
-    } else {
-      return super.isServerLibrary(librarySource);
-    }
-  }
-
-  @override
-  CompilationUnit parseCompilationUnit(Source source) {
-    if (source.isInSystemLibrary) {
-      return _sdkAnalysisContext.parseCompilationUnit(source);
-    } else {
-      return super.parseCompilationUnit(source);
-    }
-  }
-
-  @override
-  ht.HtmlUnit parseHtmlUnit(Source source) {
-    if (source.isInSystemLibrary) {
-      return _sdkAnalysisContext.parseHtmlUnit(source);
-    } else {
-      return super.parseHtmlUnit(source);
-    }
-  }
-
-  @override
-  void recordLibraryElements(Map<Source, LibraryElement> elementMap) {
-    if (elementMap.isEmpty) {
-      return;
-    }
-    // TODO(jwren) we are making the assumption here that the elementMap will have sources from only
-    // one library, while this is true with our use of the Analysis Engine, it is not required by
-    // the API, revisit to fix cases where the elementMap can have sources both in the sdk and other
-    // libraries
-    Source source = new JavaIterator(elementMap.keys.toSet()).next();
-    if (source.isInSystemLibrary) {
-      _sdkAnalysisContext.recordLibraryElements(elementMap);
-    } else {
-      super.recordLibraryElements(elementMap);
-    }
-  }
-
-  @override
-  CompilationUnit resolveCompilationUnit(Source source, LibraryElement library) {
-    if (source.isInSystemLibrary) {
-      return _sdkAnalysisContext.resolveCompilationUnit(source, library);
-    } else {
-      return super.resolveCompilationUnit(source, library);
-    }
-  }
-
-  @override
-  CompilationUnit resolveCompilationUnit2(Source unitSource, Source librarySource) {
-    if (unitSource.isInSystemLibrary) {
-      return _sdkAnalysisContext.resolveCompilationUnit2(unitSource, librarySource);
-    } else {
-      return super.resolveCompilationUnit2(unitSource, librarySource);
-    }
-  }
-
-  @override
-  ht.HtmlUnit resolveHtmlUnit(Source unitSource) {
-    if (unitSource.isInSystemLibrary) {
-      return _sdkAnalysisContext.resolveHtmlUnit(unitSource);
-    } else {
-      return super.resolveHtmlUnit(unitSource);
-    }
-  }
-
-  @override
-  void setChangedContents(Source source, String contents, int offset, int oldLength, int newLength) {
-    if (source.isInSystemLibrary) {
-      _sdkAnalysisContext.setChangedContents(source, contents, offset, oldLength, newLength);
-    } else {
-      super.setChangedContents(source, contents, offset, oldLength, newLength);
-    }
-  }
-
-  @override
-  void setContents(Source source, String contents) {
-    if (source.isInSystemLibrary) {
-      _sdkAnalysisContext.setContents(source, contents);
-    } else {
-      super.setContents(source, contents);
-    }
-  }
-
-  @override
-  void set sourceFactory(SourceFactory factory) {
-    super.sourceFactory = factory;
-    DartSdk sdk = factory.dartSdk;
-    if (sdk != null) {
-      _sdkAnalysisContext = sdk.context as InternalAnalysisContext;
-      if (_sdkAnalysisContext is DelegatingAnalysisContextImpl) {
-        _sdkAnalysisContext = null;
-        throw new IllegalStateException("The context provided by an SDK cannot itself be a delegating analysis context");
-      }
-    } else {
-      throw new IllegalStateException("SourceFactorys provided to DelegatingAnalysisContextImpls must have a DartSdk associated with the provided SourceFactory.");
-    }
-  }
-}
-
-/**
  * Instances of the class `IncrementalAnalysisCache` hold information used to perform
  * incremental analysis.
  *
  * @see AnalysisContextImpl#setChangedContents(Source, String, int, int, int)
  */
 class IncrementalAnalysisCache {
   /**
    * Determine if the incremental analysis result can be cached for the next incremental analysis.
    *
    * @param cache the prior incremental analysis cache
@@ skipping 85 matching lines @@
    * equivalent to the fully parsed unit.
    *
    * @param cache the prior cache or `null` if none
    * @param source the source of the compilation unit that was parsed (not `null`)
    * @param unit the compilation unit that was just parsed
    * @return the cache used for incremental analysis or `null` if incremental analysis results
    *         cannot be cached for the next incremental analysis
    */
   static IncrementalAnalysisCache verifyStructure(IncrementalAnalysisCache cache, Source source, CompilationUnit unit) {
     if (cache != null && unit != null && cache.source == source) {
-      if (!AstComparator.equalUnits(cache.resolvedUnit, unit)) {
+      if (!AstComparator.equalNodes(cache.resolvedUnit, unit)) {
         return null;
       }
     }
     return cache;
   }
 
   final Source librarySource;
 
   final Source source;
 
@@ skipping 84 matching lines @@
 
   /**
    * The analysis context to which all of the non-instrumentation work is delegated.
    */
   InternalAnalysisContext _basis;
 
   /**
    * Create a new [InstrumentedAnalysisContextImpl] which wraps a new
    * [AnalysisContextImpl] as the basis context.
    */
-  InstrumentedAnalysisContextImpl() : this.con1(new DelegatingAnalysisContextImpl());
+  InstrumentedAnalysisContextImpl() : this.con1(new AnalysisContextImpl());
 
   /**
    * Create a new [InstrumentedAnalysisContextImpl] with a specified basis context, aka the
    * context to wrap and instrument.
    *
    * @param context some [InstrumentedAnalysisContext] to wrap and instrument
    */
   InstrumentedAnalysisContextImpl.con1(InternalAnalysisContext context) {
     _basis = context;
   }
@@ skipping 852 matching lines @@
       onError(error);
     }
   }
 
   /**
    * Answer the errors collected by the listener.
    *
    * @return an array of errors (not `null`, contains no `null`s)
    */
   List<AnalysisError> get errors {
-    Iterable<Set<AnalysisError>> errorsSets = _errors.values;
-    int numEntries = errorsSets.length;
+    Iterable<MapEntry<Source, Set<AnalysisError>>> entrySet = getMapEntrySet(_errors);
+    int numEntries = entrySet.length;
     if (numEntries == 0) {
       return AnalysisError.NO_ERRORS;
     }
     List<AnalysisError> resultList = new List<AnalysisError>();
-    for (Set<AnalysisError> errorsSet in errorsSets) {
-      resultList.addAll(errorsSet);
+    for (MapEntry<Source, Set<AnalysisError>> entry in entrySet) {
+      resultList.addAll(entry.getValue());
     }
     return new List.from(resultList);
   }
 
   /**
    * Answer the errors collected by the listener for some passed [Source].
    *
    * @param source some [Source] for which the caller wants the set of [AnalysisError]s
    *          collected by this listener
    * @return the errors collected by the listener for the passed [Source]
@@ skipping 886 matching lines @@
 
   AngularExpression _parseAngularExpressionInToken(Token token) {
     List<Token> tokens = _splitAtBar(token);
     Expression mainExpression = _parseDartExpressionInToken(tokens[0]);
     // parse filters
     List<AngularFilterNode> filters = [];
     for (int i = 1; i < tokens.length; i++) {
       Token filterToken = tokens[i];
       Token barToken = filterToken;
       filterToken = filterToken.next;
-      // TODO(scheglov) report missing identifier
-      SimpleIdentifier name = _parseDartExpressionInToken(filterToken) as SimpleIdentifier;
+      // parse name
+      Expression nameExpression = _parseDartExpressionInToken(filterToken);
+      if (nameExpression is! SimpleIdentifier) {
+        _reportErrorForNode(AngularCode.INVALID_FILTER_NAME, nameExpression, []);
+        continue;
+      }
+      SimpleIdentifier name = nameExpression as SimpleIdentifier;
       filterToken = name.endToken.next;
       // parse arguments
       List<AngularFilterArgument> arguments = [];
       while (filterToken.type != TokenType.EOF) {
         // skip ":"
         Token colonToken = filterToken;
         if (colonToken.type == TokenType.COLON) {
           filterToken = filterToken.next;
         } else {
           _reportErrorForToken(AngularCode.MISSING_FILTER_COLON, colonToken, []);
@@ skipping 274 matching lines @@
     // simulate imports for injects
     {
       List<ImportElement> imports = [];
       for (LibraryElement injectedLibrary in _injectedLibraries) {
         ImportElementImpl importElement = new ImportElementImpl(-1);
         importElement.importedLibrary = injectedLibrary;
         imports.add(importElement);
       }
       _libraryElement.imports = new List.from(imports);
     }
-    // push conditional errors
-    for (ProxyConditionalAnalysisError conditionalCode in _resolver.proxyConditionalAnalysisErrors) {
-      _resolver.reportError(conditionalCode.analysisError);
-    }
   }
 
   void _resolveXmlExpression(AngularXmlExpression angularXmlExpression) {
     AngularExpression angularExpression = angularXmlExpression.expression;
     _resolveExpression(angularExpression);
   }
 
   List<Token> _splitAtBar(Token token) {
     List<Token> tokens = [];
     tokens.add(token);
@@ skipping 2685 matching lines @@
     //
     RecordingErrorListener errorListener = new RecordingErrorListener();
     TypeResolverVisitor typeResolverVisitor = new TypeResolverVisitor.con2(_libraryElement, source, typeProvider, errorListener);
     unit.accept(typeResolverVisitor);
     //
     // Resolve the rest of the structure
     //
     InheritanceManager inheritanceManager = new InheritanceManager(_libraryElement);
     ResolverVisitor resolverVisitor = new ResolverVisitor.con2(_libraryElement, source, typeProvider, inheritanceManager, errorListener);
     unit.accept(resolverVisitor);
-    // TODO (jwren) Move this logic/ loop into the ResolverVisitor and then make the reportError protected again.
-    for (ProxyConditionalAnalysisError conditionalCode in resolverVisitor.proxyConditionalAnalysisErrors) {
-      if (conditionalCode.shouldIncludeErrorCode()) {
-        resolverVisitor.reportError(conditionalCode.analysisError);
-      }
-    }
     //
     // Perform additional error checking.
     //
     TimeCounter_TimeCounterHandle counterHandleErrors = PerformanceStatistics.errors.start();
     try {
       ErrorReporter errorReporter = new ErrorReporter(errorListener, source);
       ErrorVerifier errorVerifier = new ErrorVerifier(errorReporter, _libraryElement, typeProvider, inheritanceManager);
       unit.accept(errorVerifier);
       ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, typeProvider);
       unit.accept(constantVerifier);
@@ skipping 299 matching lines @@
   }
 
   @override
   void logInformation(String message) {
   }
 
   @override
   void logInformation2(String message, Exception exception) {
   }
 }