New analyzer_experimental snapshot.

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

 // 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';
 import 'java_engine.dart';
 import 'utilities_collection.dart';
 import 'utilities_general.dart';
 import 'instrumentation.dart';
 import 'error.dart';
 import 'source.dart';
@@ skipping 251 matching lines @@
    * Create a new context in which analysis can be performed. Any sources in the specified container
    * will be removed from this context and added to the newly created context.
    *
    * @param container the container containing sources that should be removed from this context and
    *          added to the returned context
    * @return the analysis context that was created
    */
   AnalysisContext extractContext(SourceContainer container);
 
   /**
-   * Return the set of analysis options controlling the behavior of this context.
+   * Return the set of analysis options controlling the behavior of this context. Changes to the
+   * return options will not affect this context. The options can only be set by invoking the method
+   * [setAnalysisOptions].
    *
    * @return the set of analysis options controlling the behavior of this context
    */
   AnalysisOptions get analysisOptions;
 
   /**
    * Return the element referenced by the given location, or `null` if the element is not
    * immediately available or if there is no element with the given location. The latter condition
    * can occur, for example, if the location describes an element from a different context or if the
    * element has been removed from this context as a result of some change since it was originally
@@ skipping 124 matching lines @@
    * not known. The line information is used to map offsets from the beginning of the source to line
    * and column pairs.
    *
    * @param source the source whose line information is to be returned
    * @return the line information for the given source
    * @see #computeLineInfo(Source)
    */
   LineInfo getLineInfo(Source source);
 
   /**
+   * Return an array containing all of the sources known to this context and their resolution state
+   * is not valid or flush. So, these sources are not safe to update during refactoring, because we
+   * may be don't know all the references in them.
+   *
+   * @return the sources known to this context and are not safe for refactoring
+   */
+  List<Source> get refactoringUnsafeSources;
+
+  /**
    * Return a fully resolved AST for a single compilation unit within the given library, or
    * `null` if the resolved AST is not already computed.
    *
    * @param unitSource the source of the compilation unit
    * @param library the library containing the compilation unit
    * @return a fully resolved AST for the compilation unit
    * @see #resolveCompilationUnit(Source, LibraryElement)
    */
   CompilationUnit getResolvedCompilationUnit(Source unitSource, LibraryElement library);
 
@@ skipping 69 matching lines @@
    * resolved.
    *
    * @param source the HTML source to be parsed
    * @return the parse result (not `null`)
    * @throws AnalysisException if the analysis could not be performed
    */
   HtmlUnit parseHtmlUnit(Source source);
 
   /**
    * Perform the next unit of work required to keep the analysis results up-to-date and return
-   * information about the consequent changes to the analysis results. If there were no results the
-   * returned array will be empty. If there are no more units of work required, then this method
-   * returns `null`. This method can be long running.
+   * information about the consequent changes to the analysis results. This method can be long
+   * running.
    *
-   * @return an array containing notices of changes to the analysis results
+   * @return the results of performing the analysis
    */
-  List<ChangeNotice> performAnalysisTask();
+  AnalysisResult performAnalysisTask();
 
   /**
    * Parse and resolve a single source within the given context to produce a fully resolved AST.
    *
    * @param unitSource the source to be parsed and resolved
    * @param library the library containing the source to be resolved
    * @return the result of resolving the AST structure representing the content of the source in the
    *         context of the given library
    * @throws AnalysisException if the analysis could not be performed
    * @see #getResolvedCompilationUnit(Source, LibraryElement)
@@ skipping 40 matching lines @@
    *
    * Changes made to the list after this method returns will <b>not</b> be reflected in the priority
    * order.
    *
    * @param sources the sources to be given priority over other sources
    */
   void set analysisPriorityOrder(List<Source> sources);
 
   /**
    * Set the contents of the given source to the given contents and mark the source as having
+   * changed. The additional offset and length information is used by the context to determine what
+   * reanalysis is necessary.
+   *
+   * @param source the source whose contents are being overridden
+   * @param contents the text to replace the range in the current contents
+   * @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 setChangedContents(Source source, String contents, int offset, int oldLength, int newLength);
+
+  /**
+   * Set the contents of the given source to the given contents and mark the source as having
    * changed. This has the effect of overriding the default contents of the source. If the contents
    * are `null` the override is removed so that the default contents will be returned.
    *
    * @param source the source whose contents are being overridden
    * @param contents the new contents of the source
    */
   void setContents(Source source, String contents);
 
   /**
    * Set the source factory used to create the sources that can be analyzed in this context to the
@@ skipping 70 matching lines @@
    */
   AnalysisException.con3(Exception cause) : super.withCause(cause);
 }
 /**
  * The interface `AnalysisOptions` defines the behavior of objects that provide access to a
  * set of analysis options used to control the behavior of an analysis context.
  */
 abstract class AnalysisOptions {
 
   /**
+   * Return the maximum number of sources for which AST structures should be kept in the cache.
+   *
+   * @return the maximum number of sources for which AST structures should be kept in the cache
+   */
+  int get cacheSize;
+
+  /**
    * Return `true` if analysis is to generate dart2js related hint results.
    *
    * @return `true` if analysis is to generate dart2js related hint results
    */
   bool get dart2jsHint;
 
   /**
    * Return `true` if analysis is to generate hint results (e.g. type inference based
    * information and pub best practices).
    *
    * @return `true` if analysis is to generate hint results
    */
   bool get hint;
 
   /**
    * Return `true` if analysis is to use strict mode. In strict mode, error reporting is based
    * exclusively on the static type information.
    *
    * @return `true` if analysis is to use strict mode
    */
   bool get strictMode;
 }
 /**
+ * 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> changeNotices;
+
+  /**
+   * The number of milliseconds required to determine which task was to be performed.
+   */
+  int getTime = 0;
+
+  /**
+   * The name of the class of the task that was performed.
+   */
+  String taskClassName;
+
+  /**
+   * The number of milliseconds required to perform the task.
+   */
+  int performTime = 0;
+
+  /**
+   * Initialize a newly created analysis result to have the given values.
+   *
+   * @param notices the change notices associated with this result
+   * @param getTime the number of milliseconds required to determine which task was to be performed
+   * @param taskClassName the name of the class of the task that was performed
+   * @param performTime the number of milliseconds required to perform the task
+   */
+  AnalysisResult(List<ChangeNotice> notices, int getTime, String taskClassName, int performTime) {
+    this.changeNotices = notices;
+    this.getTime = getTime;
+    this.taskClassName = taskClassName;
+    this.performTime = performTime;
+  }
+}
+/**
  * The interface `ChangeNotice` defines the behavior of objects that represent a change to the
  * analysis results associated with a given source.
  *
  * @coverage dart.engine
  */
 abstract class ChangeNotice implements AnalysisErrorInfo {
 
   /**
    * Return the fully resolved AST that changed as a result of the analysis, or `null` if the
    * AST was not changed.
@@ skipping 145 matching lines @@
    * 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;
 
   /**
+   * The policy used to determine which pieces of data to remove from the cache.
+   */
+  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;
 
   /**
-   * An array containing sources for which data should not be flushed.
-   */
-  List<Source> _priorityOrder = Source.EMPTY_ARRAY;
-
-  /**
-   * The number of times that the flushing of information from the cache has been disabled without
-   * being re-enabled.
-   */
-  int _cacheRemovalCount = 0;
-
-  /**
    * 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) {
+  AnalysisCache(int maxCacheSize, CacheRetentionPolicy retentionPolicy) {
     this._maxCacheSize = maxCacheSize;
+    this._retentionPolicy = retentionPolicy;
     _recentlyUsed = new List<Source>();
   }
 
   /**
    * Record that the given source was just accessed.
    *
    * @param source the source that was accessed
    */
   void accessed(Source source) {
     if (_recentlyUsed.remove(source)) {
       _recentlyUsed.add(source);
       return;
     }
-    if (_cacheRemovalCount == 0 && _recentlyUsed.length >= _maxCacheSize) {
-      flushAstFromCache();
+    while (_recentlyUsed.length >= _maxCacheSize) {
+      if (!flushAstFromCache()) {
+        break;
+      }
     }
     _recentlyUsed.add(source);
   }
 
   /**
-   * Disable flushing information from the cache until [enableCacheRemoval] has been
-   * called.
-   */
-  void disableCacheRemoval() {
-    _cacheRemovalCount++;
-  }
-
-  /**
-   * Re-enable flushing information from the cache.
-   */
-  void enableCacheRemoval() {
-    if (_cacheRemovalCount > 0) {
-      _cacheRemovalCount--;
-    }
-    if (_cacheRemovalCount == 0) {
-      while (_recentlyUsed.length > _maxCacheSize) {
-        flushAstFromCache();
-      }
-    }
-  }
-
-  /**
    * Return a collection containing all of the map entries mapping sources to cache entries. Clients
    * should not modify the returned collection.
    *
    * @return a collection containing all of the map entries mapping sources to cache entries
    */
   Iterable<MapEntry<Source, SourceEntry>> entrySet() => getMapEntrySet(_sourceMap);
 
   /**
    * 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 an array containing sources for which data should not be flushed.
-   *
-   * @return an array containing sources for which data should not be flushed
-   */
-  List<Source> get priorityOrder => _priorityOrder;
-
-  /**
    * 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) {
     _sourceMap[source] = entry;
   }
 
   /**
    * Remove all information related to the given source from this cache.
    *
    * @param source the source to be removed
    */
   void remove(Source source) {
     _sourceMap.remove(source);
   }
 
   /**
-   * Set the sources for which data should not be flushed to the given array.
+   * Set the maximum size of the cache to the given size.
    *
-   * @param sources the sources for which data should not be flushed
+   * @param size the maximum number of sources for which AST structures should be kept in the cache
    */
-  void set priorityOrder(List<Source> sources) {
-    _priorityOrder = sources;
+  void set maxCacheSize(int size) {
+    _maxCacheSize = size;
+    while (_recentlyUsed.length > _maxCacheSize) {
+      if (!flushAstFromCache()) {
+        break;
+      }
+    }
   }
 
   /**
-   * Flush one AST structure from the cache.
+   * Return the number of sources that are mapped to cache entries.
+   *
+   * @return the number of sources that are mapped to cache entries
    */
-  void flushAstFromCache() {
+  int size() => _sourceMap.length;
+
+  /**
+   * Attempt to flush one AST structure from the cache.
+   *
+   * @return `true` if a structure was flushed
+   */
+  bool flushAstFromCache() {
     Source removedSource = removeAstToFlush();
+    if (removedSource == null) {
+      return false;
+    }
     SourceEntry sourceEntry = _sourceMap[removedSource];
     if (sourceEntry is HtmlEntry) {
       HtmlEntryImpl htmlCopy = ((sourceEntry as HtmlEntry)).writableCopy;
       htmlCopy.setState(HtmlEntry.PARSED_UNIT, CacheState.FLUSHED);
       _sourceMap[removedSource] = htmlCopy;
     } else if (sourceEntry is DartEntry) {
       DartEntryImpl dartCopy = ((sourceEntry as DartEntry)).writableCopy;
       dartCopy.flushAstStructures();
       _sourceMap[removedSource] = dartCopy;
     }
+    return true;
   }
 
   /**
-   * Return `true` if the given source is in the array of priority sources.
-   *
-   * @return `true` if the given source is in the array of priority sources
-   */
-  bool isPrioritySource(Source source) {
-    for (Source prioritySource in _priorityOrder) {
-      if (source == prioritySource) {
-        return true;
-      }
-    }
-    return false;
-  }
-
-  /**
    * 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.
    *
    * @return the source that was removed
    */
   Source removeAstToFlush() {
+    int sourceToRemove = -1;
     for (int i = 0; i < _recentlyUsed.length; i++) {
       Source source = _recentlyUsed[i];
-      if (!isPrioritySource(source)) {
+      RetentionPriority priority = _retentionPolicy.getAstPriority(source, _sourceMap[source]);
+      if (identical(priority, RetentionPriority.LOW)) {
         return _recentlyUsed.removeAt(i);
+      } else if (identical(priority, RetentionPriority.MEDIUM) && sourceToRemove < 0) {
+        sourceToRemove = i;
       }
     }
-    AnalysisEngine.instance.logger.logError2("Internal error: The number of priority sources (${_priorityOrder.length}) is greater than the maximum cache size (${_maxCacheSize})", new JavaException());
-    return _recentlyUsed.removeAt(0);
+    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.
+ */
+abstract class CacheRetentionPolicy {
+
+  /**
+   * Return the priority of retaining the AST structure for the given source.
+   *
+   * @param source the source whose AST structure is being considered for removal
+   * @param sourceEntry the entry representing the source
+   * @return the priority of retaining the AST structure for the given source
+   */
+  RetentionPriority getAstPriority(Source source, SourceEntry sourceEntry);
+}
+/**
  * 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:
    *
@@ skipping 172 matching lines @@
    * Return the value of the data represented by the given descriptor in the context of the given
    * library, or `null` if the data represented by the descriptor is not in the cache.
    *
    * @param descriptor the descriptor representing which data is to be returned
    * @param librarySource the source of the defining compilation unit of the library that is the
    *          context for the data
    * @return the value of the data represented by the given descriptor and library
    */
   Object getValue2(DataDescriptor descriptor, Source librarySource);
   DartEntryImpl get writableCopy;
+
+  /**
+   * Return `true` if the data represented by the given descriptor is marked as being invalid.
+   * If the descriptor represents library-specific data then this method will return `true` if
+   * the data associated with any library it marked as invalid.
+   *
+   * @param descriptor the descriptor representing which data is being tested
+   * @return `true` if the data is marked as being invalid
+   */
+  bool hasInvalidData(DataDescriptor descriptor);
+
+  /**
+   * Return `true` if this data is safe to use in refactoring.
+   */
+  bool get isRefactoringSafe;
 }
 /**
  * Instances of the class `DartEntryImpl` implement a [DartEntry].
  *
  * @coverage dart.engine
  */
 class DartEntryImpl extends SourceEntryImpl implements DartEntry {
 
   /**
    * The state of the cached source kind.
@@ skipping 302 matching lines @@
       return null;
     } else {
       throw new IllegalArgumentException("Invalid descriptor: ${descriptor}");
     }
   }
   DartEntryImpl get writableCopy {
     DartEntryImpl copy = new DartEntryImpl();
     copy.copyFrom(this);
     return copy;
   }
+  bool hasInvalidData(DataDescriptor descriptor) {
+    if (identical(descriptor, DartEntry.ELEMENT)) {
+      return identical(_elementState, CacheState.INVALID);
+    } else if (identical(descriptor, DartEntry.EXPORTED_LIBRARIES)) {
+      return identical(_exportedLibrariesState, CacheState.INVALID);
+    } else if (identical(descriptor, DartEntry.IMPORTED_LIBRARIES)) {
+      return identical(_importedLibrariesState, CacheState.INVALID);
+    } else if (identical(descriptor, DartEntry.INCLUDED_PARTS)) {
+      return identical(_includedPartsState, CacheState.INVALID);
+    } else if (identical(descriptor, DartEntry.IS_CLIENT)) {
+      return identical(_clientServerState, CacheState.INVALID);
+    } else if (identical(descriptor, DartEntry.IS_LAUNCHABLE)) {
+      return identical(_launchableState, CacheState.INVALID);
+    } else if (identical(descriptor, DartEntry.PARSE_ERRORS)) {
+      return identical(_parseErrorsState, CacheState.INVALID);
+    } else if (identical(descriptor, DartEntry.PARSED_UNIT)) {
+      return identical(_parsedUnitState, CacheState.INVALID);
+    } else if (identical(descriptor, DartEntry.PUBLIC_NAMESPACE)) {
+      return identical(_publicNamespaceState, CacheState.INVALID);
+    } else if (identical(descriptor, DartEntry.SOURCE_KIND)) {
+      return identical(_sourceKindState, 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);
+        } else if (identical(descriptor, DartEntry.RESOLVED_UNIT)) {
+          return identical(state._resolvedUnitState, CacheState.INVALID);
+        } else if (identical(descriptor, DartEntry.VERIFICATION_ERRORS)) {
+          return identical(state._verificationErrorsState, CacheState.INVALID);
+        } else if (identical(descriptor, DartEntry.HINTS)) {
+          return identical(state._hintsState, CacheState.INVALID);
+        }
+      }
+      return false;
+    } else {
+      return identical(super.getState(descriptor), CacheState.INVALID);
+    }
+  }
 
   /**
    * Invalidate all of the information associated with the compilation unit.
    */
   void invalidateAllInformation() {
     setState(SourceEntry.LINE_INFO, CacheState.INVALID);
     _sourceKind = SourceKind.UNKNOWN;
     _sourceKindState = CacheState.INVALID;
     _parseErrors = AnalysisError.NO_ERRORS;
     _parseErrorsState = CacheState.INVALID;
@@ skipping 15 matching lines @@
     _exportedLibrariesState = CacheState.INVALID;
     _importedLibraries = Source.EMPTY_ARRAY;
     _importedLibrariesState = CacheState.INVALID;
     _bitmask = 0;
     _clientServerState = CacheState.INVALID;
     _launchableState = CacheState.INVALID;
     _publicNamespace = null;
     _publicNamespaceState = CacheState.INVALID;
     _resolutionState.invalidateAllResolutionInformation();
   }
+  bool get isRefactoringSafe {
+    DartEntryImpl_ResolutionState state = _resolutionState;
+    while (state != null) {
+      CacheState resolvedState = state._resolvedUnitState;
+      if (resolvedState != CacheState.VALID && resolvedState != CacheState.FLUSHED) {
+        return false;
+      }
+      state = state._nextState;
+    }
+    return true;
+  }
 
   /**
    * Record that an error occurred while attempting to scan or parse the entry represented by this
    * entry. This will set the state of all information, including any resolution-based information,
    * as being in error.
    */
   void recordParseError() {
     setState(SourceEntry.LINE_INFO, CacheState.ERROR);
     _sourceKind = SourceKind.UNKNOWN;
     _sourceKindState = CacheState.ERROR;
@@ skipping 492 matching lines @@
     _hintsState = CacheState.INVALID;
     _hints = AnalysisError.NO_ERRORS;
   }
 
   /**
    * 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() {
-    _nextState = null;
-    _librarySource = null;
     _resolvedUnitState = CacheState.ERROR;
     _resolvedUnit = null;
     _resolutionErrorsState = CacheState.ERROR;
     _resolutionErrors = AnalysisError.NO_ERRORS;
     _verificationErrorsState = CacheState.ERROR;
     _verificationErrors = AnalysisError.NO_ERRORS;
     _hintsState = CacheState.ERROR;
     _hints = AnalysisError.NO_ERRORS;
+    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)) {
       _resolvedUnitState = CacheState.INVALID;
     }
@@ skipping 295 matching lines @@
     builder.append(_parsedUnitState);
     builder.append("; resolutionErrors = ");
     builder.append(_resolutionErrorsState);
     builder.append("; referencedLibraries = ");
     builder.append(_referencedLibrariesState);
     builder.append("; element = ");
     builder.append(_elementState);
   }
 }
 /**
+ * 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);
+
+  /**
+   * 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);
+
+  /**
+   * 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 final List<RetentionPriority> values = [LOW, MEDIUM, HIGH];
+  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.
  *
  * @coverage dart.engine
  */
 abstract class SourceEntry {
 
@@ skipping 270 matching lines @@
   }
 }
 /**
  * Instances of the class `AnalysisContextImpl` implement an [AnalysisContext].
  *
  * @coverage dart.engine
  */
 class AnalysisContextImpl implements InternalAnalysisContext {
 
   /**
+   * The difference between the maximum cache size and the maximum priority order size. The priority
+   * list must be capped so that it is 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.
+   */
+  static int _PRIORITY_ORDER_SIZE_DELTA = 4;
+
+  /**
    * The set of analysis options controlling the behavior of this context.
    */
-  AnalysisOptions _options = new AnalysisOptionsImpl();
+  AnalysisOptionsImpl _options = new AnalysisOptionsImpl();
 
   /**
    * The source factory used to create the sources that can be analyzed in this context.
    */
   SourceFactory _sourceFactory;
 
   /**
    * A table mapping the sources known to the context to the information known about the source.
    */
-  AnalysisCache _cache = new AnalysisCache(_MAX_CACHE_SIZE);
+  AnalysisCache _cache;
+
+  /**
+   * An array containing sources for which data should not be flushed.
+   */
+  List<Source> _priorityOrder = Source.EMPTY_ARRAY;
 
   /**
    * A table mapping sources to the change notices that are waiting to be returned related to that
    * source.
    */
   Map<Source, ChangeNoticeImpl> _pendingNotices = new Map<Source, ChangeNoticeImpl>();
 
   /**
    * 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();
 
   /**
    * The object used to record the results of performing an analysis task.
    */
   AnalysisContextImpl_AnalysisTaskResultRecorder _resultRecorder;
 
   /**
-   * The maximum number of sources for which data should be kept in the cache.
-   */
-  static int _MAX_CACHE_SIZE = 64;
-
-  /**
-   * The maximum number of sources that can be on the priority list. This <b>must</b> be less than
-   * the [MAX_CACHE_SIZE] in order to prevent an infinite loop in performAnalysisTask().
-   *
-   * @see #setAnalysisPriorityOrder(List)
-   */
-  static int _MAX_PRIORITY_LIST_SIZE = _MAX_CACHE_SIZE - 4;
-
-  /**
    * Initialize a newly created analysis context.
    */
   AnalysisContextImpl() : super() {
     _resultRecorder = new AnalysisContextImpl_AnalysisTaskResultRecorder(this);
+    _cache = new AnalysisCache(AnalysisOptionsImpl.DEFAULT_CACHE_SIZE, new AnalysisContextImpl_ContextRetentionPolicy(this));
   }
   void addSourceInfo(Source source, SourceEntry info) {
     _cache.put(source, info);
   }
   void applyChanges(ChangeSet changeSet) {
     if (changeSet.isEmpty) {
       return;
     }
     {
       List<Source> removedSources = new List<Source>.from(changeSet.removed3);
@@ skipping 119 matching lines @@
     return null;
   }
   ResolvableCompilationUnit computeResolvableCompilationUnit(Source source) {
     while (true) {
       {
         DartEntry dartEntry = getReadableDartEntry(source);
         if (dartEntry == null) {
           throw new AnalysisException.con1("computeResolvableCompilationUnit for non-Dart: ${source.fullName}");
         }
         if (identical(dartEntry.getState(DartEntry.PARSED_UNIT), CacheState.ERROR)) {
-          throw new AnalysisException.con1("Internal error: computeResolvableCompilationUnit could not parse ${source.fullName}");
+          AnalysisException cause = dartEntry.exception;
+          if (cause == null) {
+            throw new AnalysisException.con1("Internal error: computeResolvableCompilationUnit could not parse ${source.fullName}");
+          } else {
+            throw new AnalysisException.con2("Internal error: computeResolvableCompilationUnit could not parse ${source.fullName}", cause);
+          }
         }
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         CompilationUnit unit = dartCopy.resolvableCompilationUnit;
         if (unit != null) {
           _cache.put(source, dartCopy);
           return new ResolvableCompilationUnit(dartCopy.modificationTime, unit);
         }
       }
       cacheDartParseData(source, getReadableDartEntry(source), DartEntry.PARSED_UNIT);
     }
@@ skipping 17 matching lines @@
       for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
         Source source = entry.getKey();
         if (container.contains(source)) {
           sourcesToRemove.add(source);
           newContext.addSourceInfo(source, entry.getValue().writableCopy);
         }
       }
     }
     return newContext;
   }
-  AnalysisOptions get analysisOptions => _options;
+  AnalysisOptions get analysisOptions => new AnalysisOptionsImpl.con1(_options);
   Element getElement(ElementLocation location) {
     try {
       List<String> components = ((location as ElementLocationImpl)).components;
       Source librarySource = computeSourceFromEncoding(components[0]);
       ElementImpl element = computeLibraryElement(librarySource) as ElementImpl;
       for (int i = 1; i < components.length; i++) {
         if (element == null) {
           return null;
         }
         element = element.getChild(components[i]);
@@ skipping 188 matching lines @@
         }
         if (identical(dartEntry.getValue(DartEntry.ELEMENT), library)) {
           DartEntryImpl dartCopy = getReadableDartEntry(source).writableCopy;
           dartCopy.setValue(DartEntry.PUBLIC_NAMESPACE, namespace);
           _cache.put(source, dartCopy);
         }
       }
     }
     return namespace;
   }
+  List<Source> get refactoringUnsafeSources {
+    List<Source> sources = new List<Source>();
+    {
+      for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
+        SourceEntry sourceEntry = entry.getValue();
+        if (sourceEntry is DartEntry) {
+          if (!((sourceEntry as DartEntry)).isRefactoringSafe) {
+            sources.add(entry.getKey());
+          }
+        }
+      }
+    }
+    return new List.from(sources);
+  }
   CompilationUnit getResolvedCompilationUnit(Source unitSource, LibraryElement library) {
     if (library == null) {
       return null;
     }
     return getResolvedCompilationUnit2(unitSource, library.source);
   }
   CompilationUnit getResolvedCompilationUnit2(Source unitSource, Source librarySource) {
     SourceEntry sourceEntry = getReadableSourceEntry(unitSource);
     if (sourceEntry is DartEntry) {
       return ((sourceEntry as DartEntry)).getValue2(DartEntry.RESOLVED_UNIT, librarySource);
     }
     return null;
   }
   SourceFactory get sourceFactory => _sourceFactory;
 
   /**
    * Return a list of the sources that would be processed by [performAnalysisTask]. This
    * method duplicates, and must therefore be kept in sync with, [getNextTaskAnalysisTask].
    * This method is intended to be used for testing purposes only.
    *
    * @return a list of the sources that would be processed by [performAnalysisTask]
    */
   List<Source> get sourcesNeedingProcessing {
     Set<Source> sources = new Set<Source>();
     {
       bool hintsEnabled = analysisOptions.hint;
-      for (Source source in _cache.priorityOrder) {
+      for (Source source in _priorityOrder) {
         getSourcesNeedingProcessing2(source, _cache.get(source), true, hintsEnabled, sources);
       }
       for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
         getSourcesNeedingProcessing2(entry.getKey(), entry.getValue(), false, hintsEnabled, sources);
       }
     }
     return new List<Source>.from(sources);
   }
   AnalysisContentStatistics get statistics {
     AnalysisContentStatisticsImpl statistics = new AnalysisContentStatisticsImpl();
@@ skipping 66 matching lines @@
         SourceEntry existingEntry = getReadableSourceEntry(newSource);
         if (existingEntry == null) {
           _cache.put(newSource, entry.getValue().writableCopy);
         } else {
         }
       }
     }
   }
   CompilationUnit parseCompilationUnit(Source source) => getDartParseData2(source, DartEntry.PARSED_UNIT, null);
   HtmlUnit parseHtmlUnit(Source source) => getHtmlParseData(source, HtmlEntry.PARSED_UNIT, null);
-  List<ChangeNotice> performAnalysisTask() {
+  AnalysisResult performAnalysisTask() {
+    int getStart = JavaSystem.currentTimeMillis();
     AnalysisTask task = nextTaskAnalysisTask;
+    int getEnd = JavaSystem.currentTimeMillis();
     if (task == null) {
-      return getChangeNotices(true);
+      return new AnalysisResult(getChangeNotices(true), getEnd - getStart, null, -1);
     }
+    int performStart = JavaSystem.currentTimeMillis();
     try {
       task.perform(_resultRecorder);
     } on AnalysisException catch (exception) {
       if (exception.cause is! JavaIOException) {
         AnalysisEngine.instance.logger.logError2("Internal error while performing the task: ${task}", exception);
       }
     }
-    return getChangeNotices(false);
+    int performEnd = JavaSystem.currentTimeMillis();
+    return new AnalysisResult(getChangeNotices(false), getEnd - getStart, task.runtimeType.toString(), performEnd - performStart);
   }
   void recordLibraryElements(Map<Source, LibraryElement> elementMap) {
     {
       Source htmlSource = _sourceFactory.forUri(DartSdk.DART_HTML);
       for (MapEntry<Source, LibraryElement> entry in getMapEntrySet(elementMap)) {
         Source librarySource = entry.getKey();
         LibraryElement library = entry.getValue();
         DartEntry dartEntry = getReadableDartEntry(librarySource);
         if (dartEntry != null) {
           DartEntryImpl dartCopy = dartEntry.writableCopy;
           recordElementData(dartCopy, library, htmlSource);
           _cache.put(librarySource, dartCopy);
         }
       }
     }
   }
   CompilationUnit resolveCompilationUnit(Source unitSource, LibraryElement library) {
     if (library == null) {
       return null;
     }
     return resolveCompilationUnit2(unitSource, library.source);
   }
   CompilationUnit resolveCompilationUnit2(Source unitSource, Source librarySource) => getDartResolutionData2(unitSource, librarySource, DartEntry.RESOLVED_UNIT, null);
   HtmlUnit resolveHtmlUnit(Source htmlSource) => parseHtmlUnit(htmlSource);
   void set analysisOptions(AnalysisOptions options) {
     {
-      this._options = options;
-      invalidateAllResolutionInformation();
+      bool needsRecompute = this._options.dart2jsHint != options.dart2jsHint || (this._options.hint && !options.hint);
+      int cacheSize = options.cacheSize;
+      if (this._options.cacheSize != cacheSize) {
+        this._options.cacheSize = cacheSize;
+        _cache.maxCacheSize = cacheSize;
+        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.dart2jsHint = options.dart2jsHint;
+      this._options.hint = options.hint;
+      this._options.strictMode = options.strictMode;
+      if (needsRecompute) {
+        invalidateAllResolutionInformation();
+      }
     }
   }
   void set analysisPriorityOrder(List<Source> sources) {
     {
       if (sources == null || sources.isEmpty) {
-        _cache.priorityOrder = Source.EMPTY_ARRAY;
+        _priorityOrder = Source.EMPTY_ARRAY;
       } else {
         while (sources.remove(null)) {
         }
         if (sources.isEmpty) {
-          _cache.priorityOrder = Source.EMPTY_ARRAY;
+          _priorityOrder = Source.EMPTY_ARRAY;
         }
-        int count = Math.min(sources.length, _MAX_PRIORITY_LIST_SIZE);
-        List<Source> priorityOrder = new List<Source>(count);
+        int count = Math.min(sources.length, _options.cacheSize - _PRIORITY_ORDER_SIZE_DELTA);
+        _priorityOrder = new List<Source>(count);
         for (int i = 0; i < count; i++) {
-          priorityOrder[i] = sources[i];
+          _priorityOrder[i] = sources[i];
         }
-        _cache.priorityOrder = priorityOrder;
       }
     }
   }
+  void setChangedContents(Source source, String contents, int offset, int oldLength, int newLength) {
+    {
+      if (_sourceFactory.setContents(source, contents)) {
+        sourceChanged(source);
+      }
+    }
+  }
   void setContents(Source source, String contents) {
     {
       if (_sourceFactory.setContents(source, contents)) {
         sourceChanged(source);
       }
     }
   }
   void set sourceFactory(SourceFactory factory) {
     {
       if (identical(_sourceFactory, factory)) {
@@ skipping 465 matching lines @@
 
   /**
    * Look through the cache for a task that needs to be performed. Return the task that was found,
    * or `null` if there is no more work to be done.
    *
    * @return the next task that needs to be performed
    */
   AnalysisTask get nextTaskAnalysisTask {
     {
       bool hintsEnabled = analysisOptions.hint;
-      for (Source source in _cache.priorityOrder) {
+      for (Source source in _priorityOrder) {
         AnalysisTask task = getNextTaskAnalysisTask2(source, _cache.get(source), true, hintsEnabled);
         if (task != null) {
           return task;
         }
       }
       for (MapEntry<Source, SourceEntry> entry in _cache.entrySet()) {
         AnalysisTask task = getNextTaskAnalysisTask2(entry.getKey(), entry.getValue(), false, hintsEnabled);
         if (task != null) {
           return task;
         }
@@ skipping 18 matching lines @@
   AnalysisTask getNextTaskAnalysisTask2(Source source, SourceEntry sourceEntry, bool isPriority, bool hintsEnabled) {
     if (sourceEntry is DartEntry) {
       DartEntry dartEntry = sourceEntry as DartEntry;
       CacheState parseErrorsState = dartEntry.getState(DartEntry.PARSE_ERRORS);
       if (identical(parseErrorsState, CacheState.INVALID) || (isPriority && identical(parseErrorsState, CacheState.FLUSHED))) {
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         dartCopy.setState(DartEntry.PARSE_ERRORS, CacheState.IN_PROCESS);
         _cache.put(source, dartCopy);
         return new ParseDartTask(this, source);
       }
-      if (isPriority) {
+      if (isPriority && parseErrorsState != CacheState.ERROR) {
         CompilationUnit parseUnit = dartEntry.anyParsedCompilationUnit;
         if (parseUnit == null) {
           DartEntryImpl dartCopy = dartEntry.writableCopy;
           dartCopy.setState(DartEntry.PARSED_UNIT, CacheState.IN_PROCESS);
           _cache.put(source, dartCopy);
           return new ParseDartTask(this, source);
         }
       }
       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))) {
             DartEntryImpl libraryCopy = ((libraryEntry as DartEntry)).writableCopy;
             libraryCopy.setState(DartEntry.ELEMENT, CacheState.IN_PROCESS);
             _cache.put(librarySource, libraryCopy);
             return new ResolveDartLibraryTask(this, source, librarySource);
           }
           CacheState resolvedUnitState = dartEntry.getState2(DartEntry.RESOLVED_UNIT, librarySource);
           if (identical(resolvedUnitState, CacheState.INVALID) || (isPriority && identical(resolvedUnitState, CacheState.FLUSHED))) {
-            LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
-            if (libraryElement != null) {
-              DartEntryImpl dartCopy = dartEntry.writableCopy;
-              dartCopy.setState2(DartEntry.RESOLVED_UNIT, librarySource, CacheState.IN_PROCESS);
-              _cache.put(source, dartCopy);
-              return new ResolveDartUnitTask(this, source, libraryElement);
-            }
+            DartEntryImpl dartCopy = dartEntry.writableCopy;
+            dartCopy.setState2(DartEntry.RESOLVED_UNIT, librarySource, CacheState.IN_PROCESS);
+            _cache.put(source, dartCopy);
+            return new ResolveDartLibraryTask(this, source, librarySource);
           }
           CacheState verificationErrorsState = dartEntry.getState2(DartEntry.VERIFICATION_ERRORS, librarySource);
           if (identical(verificationErrorsState, CacheState.INVALID) || (isPriority && identical(verificationErrorsState, CacheState.FLUSHED))) {
             LibraryElement libraryElement = libraryEntry.getValue(DartEntry.ELEMENT);
             if (libraryElement != null) {
               DartEntryImpl dartCopy = dartEntry.writableCopy;
               dartCopy.setState2(DartEntry.VERIFICATION_ERRORS, librarySource, CacheState.IN_PROCESS);
               _cache.put(source, dartCopy);
               return new GenerateDartErrorsTask(this, source, libraryElement);
             }
@@ skipping 622 matching lines @@
       }
       {
         if (allModificationTimesMatch(resolvedLibraries)) {
           Source htmlSource = sourceFactory.forUri(DartSdk.DART_HTML);
           RecordingErrorListener errorListener = resolver.errorListener;
           for (Library library in resolvedLibraries) {
             Source librarySource = library.librarySource;
             for (Source source in library.compilationUnitSources) {
               CompilationUnit unit = library.getAST(source);
               List<AnalysisError> errors = errorListener.getErrors2(source);
-              unit.resolutionErrors = errors;
-              LineInfo lineInfo = unit.lineInfo;
+              LineInfo lineInfo = getLineInfo(source);
               DartEntry dartEntry = _cache.get(source) as DartEntry;
               int sourceTime = source.modificationStamp;
               if (dartEntry.modificationTime != sourceTime) {
                 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;
@@ skipping 256 matching lines @@
   final AnalysisContextImpl AnalysisContextImpl_this;
   AnalysisContextImpl_AnalysisTaskResultRecorder(this.AnalysisContextImpl_this);
   SourceEntry visitGenerateDartErrorsTask(GenerateDartErrorsTask task) => AnalysisContextImpl_this.recordGenerateDartErrorsTask(task);
   SourceEntry visitGenerateDartHintsTask(GenerateDartHintsTask task) => AnalysisContextImpl_this.recordGenerateDartHintsTask(task);
   DartEntry visitParseDartTask(ParseDartTask task) => AnalysisContextImpl_this.recordParseDartTaskResults(task);
   HtmlEntry visitParseHtmlTask(ParseHtmlTask task) => AnalysisContextImpl_this.recordParseHtmlTaskResults(task);
   DartEntry visitResolveDartLibraryTask(ResolveDartLibraryTask task) => AnalysisContextImpl_this.recordResolveDartLibraryTaskResults(task);
   SourceEntry visitResolveDartUnitTask(ResolveDartUnitTask task) => AnalysisContextImpl_this.recordResolveDartUnitTaskResults(task);
   SourceEntry visitResolveHtmlTask(ResolveHtmlTask task) => AnalysisContextImpl_this.recordResolveHtmlTaskResults(task);
 }
+class AnalysisContextImpl_ContextRetentionPolicy implements CacheRetentionPolicy {
+  final AnalysisContextImpl AnalysisContextImpl_this;
+  AnalysisContextImpl_ContextRetentionPolicy(this.AnalysisContextImpl_this);
+  RetentionPriority getAstPriority(Source source, SourceEntry sourceEntry) {
+    for (Source prioritySource in AnalysisContextImpl_this._priorityOrder) {
+      if (source == prioritySource) {
+        return RetentionPriority.HIGH;
+      }
+    }
+    if (sourceEntry is DartEntry) {
+      DartEntry dartEntry = sourceEntry as DartEntry;
+      if (astIsNeeded(dartEntry)) {
+        return RetentionPriority.MEDIUM;
+      }
+    }
+    return RetentionPriority.LOW;
+  }
+  bool astIsNeeded(DartEntry dartEntry) => dartEntry.hasInvalidData(DartEntry.HINTS) || dartEntry.hasInvalidData(DartEntry.VERIFICATION_ERRORS) || dartEntry.hasInvalidData(DartEntry.RESOLUTION_ERRORS);
+}
 /**
  * Instances of the class `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;
@@ skipping 29 matching lines @@
    */
   LineInfo get lineInfo => _lineInfo;
 }
 /**
  * Instances of the class `AnalysisOptions` represent a set of analysis options used to
  * control the behavior of an analysis context.
  */
 class AnalysisOptionsImpl implements AnalysisOptions {
 
   /**
-   * A flag indicating whether analysis is to use strict mode. In strict mode, error reporting is
-   * based exclusively on the static type information.
+   * The maximum number of sources for which data should be kept in the cache.
    */
-  bool _strictMode = true;
+  static int DEFAULT_CACHE_SIZE = 64;
+
+  /**
+   * The maximum number of sources for which AST structures should be kept in the cache.
+   */
+  int _cacheSize = DEFAULT_CACHE_SIZE;
+
+  /**
+   * A flag indicating whether analysis is to generate dart2js related hint results.
+   */
+  bool _dart2jsHint = true;
 
   /**
    * A flag indicating whether analysis is to generate hint results (e.g. type inference based
    * information and pub best practices).
    */
   bool _hint = true;
 
   /**
-   * A flag indicating whether analysis is to generate dart2js related hint results.
+   * A flag indicating whether analysis is to use strict mode. In strict mode, error reporting is
+   * based exclusively on the static type information.
    */
-  bool _dart2jsHint = true;
+  bool _strictMode = true;
+
+  /**
+   * Initialize a newly created set of analysis options to have their default values.
+   */
+  AnalysisOptionsImpl();
+
+  /**
+   * Initialize a newly created set of analysis options to have the same values as those in the
+   * given set of analysis options.
+   *
+   * @param options the analysis options whose values are being copied
+   */
+  AnalysisOptionsImpl.con1(AnalysisOptions options) {
+    _cacheSize = options.cacheSize;
+    _dart2jsHint = options.dart2jsHint;
+    _hint = options.hint;
+    _strictMode = options.strictMode;
+  }
+  int get cacheSize => _cacheSize;
   bool get dart2jsHint => _dart2jsHint;
   bool get hint => _hint;
 
   /**
    * Return `true` if analysis is to use strict mode. In strict mode, error reporting is based
    * exclusively on the static type information.
    *
    * @return `true` if analysis is to use strict mode
    */
   bool get strictMode => _strictMode;
 
   /**
+   * Set the maximum number of sources for which AST structures should be kept in the cache to the
+   * given size.
+   *
+   * @param cacheSize the maximum number of sources for which AST structures should be kept in the
+   *          cache
+   */
+  void set cacheSize(int cacheSize) {
+    this._cacheSize = cacheSize;
+  }
+
+  /**
    * Set whether analysis is to generate dart2js related hint results.
    *
    * @param hint `true` if analysis is to generate dart2js related hint results
    */
   void set dart2jsHint(bool dart2jsHints) {
     this._dart2jsHint = dart2jsHints;
   }
 
   /**
    * Set whether analysis is to generate hint results (e.g. type inference based information and pub
@@ skipping 331 matching lines @@
       return super.resolveCompilationUnit2(unitSource, librarySource);
     }
   }
   HtmlUnit resolveHtmlUnit(Source unitSource) {
     if (unitSource.isInSystemLibrary) {
       return _sdkAnalysisContext.resolveHtmlUnit(unitSource);
     } else {
       return super.resolveHtmlUnit(unitSource);
     }
   }
+  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);
+    }
+  }
   void setContents(Source source, String contents) {
     if (source.isInSystemLibrary) {
       _sdkAnalysisContext.setContents(source, contents);
     } else {
       super.setContents(source, contents);
     }
   }
   void set sourceFactory(SourceFactory factory) {
     super.sourceFactory = factory;
     DartSdk sdk = factory.dartSdk;
@@ skipping 314 matching lines @@
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getLineInfo");
     try {
       instrumentation.metric3("contextId", _contextId);
       return basis.getLineInfo(source);
     } finally {
       instrumentation.log();
     }
   }
   Namespace getPublicNamespace(LibraryElement library) => basis.getPublicNamespace(library);
   Namespace getPublicNamespace2(Source source) => basis.getPublicNamespace2(source);
+  List<Source> get refactoringUnsafeSources => basis.refactoringUnsafeSources;
   CompilationUnit getResolvedCompilationUnit(Source unitSource, LibraryElement library) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-getResolvedCompilationUnit");
     try {
       instrumentation.metric3("contextId", _contextId);
       return basis.getResolvedCompilationUnit(unitSource, library);
     } finally {
       instrumentation.log();
     }
   }
   CompilationUnit getResolvedCompilationUnit2(Source unitSource, Source librarySource) {
@@ skipping 63 matching lines @@
     try {
       instrumentation.metric3("contextId", _contextId);
       return basis.parseHtmlUnit(source);
     } on AnalysisException catch (e) {
       recordAnalysisException(instrumentation, e);
       throw e;
     } finally {
       instrumentation.log();
     }
   }
-  List<ChangeNotice> performAnalysisTask() {
+  AnalysisResult performAnalysisTask() {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-performAnalysisTask");
     try {
       instrumentation.metric3("contextId", _contextId);
-      List<ChangeNotice> ret = basis.performAnalysisTask();
-      if (ret != null) {
-        instrumentation.metric2("ChangeNotice-count", ret.length);
+      AnalysisResult result = basis.performAnalysisTask();
+      if (result.changeNotices != null) {
+        instrumentation.metric2("ChangeNotice-count", result.changeNotices.length);
       }
-      return ret;
+      return result;
     } finally {
       instrumentation.log2(2);
     }
   }
   void recordLibraryElements(Map<Source, LibraryElement> elementMap) {
     basis.recordLibraryElements(elementMap);
   }
   CompilationUnit resolveCompilationUnit(Source unitSource, LibraryElement library) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-resolveCompilationUnit");
     try {
@@ skipping 41 matching lines @@
   }
   void set analysisPriorityOrder(List<Source> sources) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-setAnalysisPriorityOrder");
     try {
       instrumentation.metric3("contextId", _contextId);
       basis.analysisPriorityOrder = sources;
     } finally {
       instrumentation.log();
     }
   }
+  void setChangedContents(Source source, String contents, int offset, int oldLength, int newLength) {
+    InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-setChangedContents");
+    try {
+      instrumentation.metric3("contextId", _contextId);
+      basis.setChangedContents(source, contents, offset, oldLength, newLength);
+    } finally {
+      instrumentation.log();
+    }
+  }
   void setContents(Source source, String contents) {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("Analysis-setContents");
     try {
       instrumentation.metric3("contextId", _contextId);
       basis.setContents(source, contents);
     } finally {
       instrumentation.log();
     }
   }
   void set sourceFactory(SourceFactory factory) {
@@ skipping 562 matching lines @@
    * @param source the source for which errors and warnings are to be produced
    * @param libraryElement the element model for the library containing the source
    */
   GenerateDartErrorsTask(InternalAnalysisContext context, Source source, LibraryElement libraryElement) : super(context) {
     this.source = source;
     this.libraryElement = libraryElement;
   }
   accept(AnalysisTaskVisitor visitor) => visitor.visitGenerateDartErrorsTask(this);
   String get taskDescription => "generate errors and warnings for ${source.fullName}";
   void internalPerform() {
+    InternalAnalysisContext context = this.context;
+    TimestampedData<CompilationUnit> data = context.internalResolveCompilationUnit(source, libraryElement);
     TimeCounter_TimeCounterHandle timeCounter = PerformanceStatistics.errors.start();
     try {
-      InternalAnalysisContext context = this.context;
-      TimestampedData<CompilationUnit> data = context.internalResolveCompilationUnit(source, libraryElement);
       modificationTime = data.modificationTime;
       CompilationUnit unit = data.data;
       RecordingErrorListener errorListener = new RecordingErrorListener();
       ErrorReporter errorReporter = new ErrorReporter(errorListener, source);
       Source coreSource = context.sourceFactory.forUri(DartSdk.DART_CORE);
       LibraryElement coreLibrary = context.getLibraryElement(coreSource);
       TypeProvider typeProvider = new TypeProviderImpl(coreLibrary);
       ConstantVerifier constantVerifier = new ConstantVerifier(errorReporter, typeProvider);
       unit.accept(constantVerifier);
       ErrorVerifier errorVerifier = new ErrorVerifier(errorReporter, libraryElement, typeProvider, new InheritanceManager(libraryElement));
@@ skipping 39 matching lines @@
   }
   void internalPerform() {
     RecordingErrorListener errorListener = new RecordingErrorListener();
     List<CompilationUnitElement> parts = libraryElement.parts;
     int partCount = parts.length;
     List<CompilationUnit> compilationUnits = new List<CompilationUnit>(partCount + 1);
     Map<Source, TimestampedData<CompilationUnit>> timestampMap = new Map<Source, TimestampedData<CompilationUnit>>();
     Source unitSource = libraryElement.definingCompilationUnit.source;
     TimestampedData<CompilationUnit> resolvedUnit = getCompilationUnit(unitSource);
     timestampMap[unitSource] = resolvedUnit;
-    compilationUnits[0] = resolvedUnit.data;
+    CompilationUnit unit = resolvedUnit.data;
+    if (unit == null) {
+      throw new AnalysisException.con1("Internal error: GenerateDartHintsTask failed to access resolved compilation unit for ${unitSource.fullName}");
+    }
+    compilationUnits[0] = unit;
     for (int i = 0; i < partCount; i++) {
       unitSource = parts[i].source;
       resolvedUnit = getCompilationUnit(unitSource);
       timestampMap[unitSource] = resolvedUnit;
-      compilationUnits[i + 1] = resolvedUnit.data;
+      unit = resolvedUnit.data;
+      if (unit == null) {
+        throw new AnalysisException.con1("Internal error: GenerateDartHintsTask failed to access resolved compilation unit for ${unitSource.fullName}");
+      }
+      compilationUnits[i + 1] = unit;
     }
     HintGenerator hintGenerator = new HintGenerator(compilationUnits, context, errorListener);
     hintGenerator.generateForLibrary();
     hintMap = new Map<Source, TimestampedData<List<AnalysisError>>>();
     for (MapEntry<Source, TimestampedData<CompilationUnit>> entry in getMapEntrySet(timestampMap)) {
       Source source = entry.getKey();
       TimestampedData<CompilationUnit> unitData = entry.getValue();
       List<AnalysisError> errors = errorListener.getErrors2(source);
       hintMap[source] = new TimestampedData<List<AnalysisError>>(unitData.modificationTime, errors);
-      unitData.data.hints = errors;
     }
   }
 
   /**
    * Return the resolved compilation unit associated with the given source.
    *
    * @param unitSource the source for the compilation unit whose resolved AST is to be returned
    * @return the resolved compilation unit associated with the given source
    * @throws AnalysisException if the resolved compilation unit could not be computed
    */
@@ skipping 145 matching lines @@
           _hasLibraryDirective2 = true;
         } else if (directive is PartDirective) {
           Source partSource = resolveSource(source, directive as PartDirective);
           if (partSource != null) {
             javaSetAdd(_includedSources, partSource);
           }
         } else if (directive is PartOfDirective) {
           _hasPartOfDirective2 = true;
         }
       }
-      compilationUnit.parsingErrors = errors;
-      compilationUnit.lineInfo = lineInfo;
     } finally {
       timeCounterParse.stop();
     }
   }
 
   /**
    * Return the result of resolving the URI of the given URI-based directive against the URI of the
    * given library, or `null` if the URI is not valid.
    *
    * @param librarySource the source representing the library containing the directive
@@ skipping 298 matching lines @@
     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);
     } finally {
       counterHandleErrors.stop();
     }
-    unit.resolutionErrors = errorListener.errors;
     resolvedUnit = unit;
   }
 
   /**
    * Search the compilation units that are part of the given library and return the element
    * representing the compilation unit with the given source. Return `null` if there is no
    * such compilation unit.
    *
    * @param libraryElement the element representing the library being searched through
    * @param unitSource the source for the compilation unit whose element is to be returned
@@ skipping 122 matching lines @@
   }
   void logError2(String message, Exception exception) {
   }
   void logError3(Exception exception) {
   }
   void logInformation(String message) {
   }
   void logInformation2(String message, Exception exception) {
   }
 }