New analyzer snapshot.

pkg/analyzer/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 3382 matching lines @@
     {
       for (MapEntry<Source, SourceEntry> mapEntry in _cache.entrySet()) {
         SourceEntry entry = mapEntry.getValue();
         if (entry is DartEntry) {
           Source source = mapEntry.getKey();
           DartEntry dartEntry = entry as DartEntry;
           SourceKind kind = dartEntry.getValue(DartEntry.SOURCE_KIND);
           statistics.putCacheItem(dartEntry, DartEntry.PARSE_ERRORS);
           statistics.putCacheItem(dartEntry, DartEntry.PARSED_UNIT);
           statistics.putCacheItem(dartEntry, DartEntry.SOURCE_KIND);
-          statistics.putCacheItem(dartEntry, DartEntry.LINE_INFO);
+          statistics.putCacheItem(dartEntry, SourceEntry.LINE_INFO);
           if (identical(kind, SourceKind.LIBRARY)) {
             statistics.putCacheItem(dartEntry, DartEntry.ELEMENT);
             statistics.putCacheItem(dartEntry, DartEntry.EXPORTED_LIBRARIES);
             statistics.putCacheItem(dartEntry, DartEntry.IMPORTED_LIBRARIES);
             statistics.putCacheItem(dartEntry, DartEntry.INCLUDED_PARTS);
             statistics.putCacheItem(dartEntry, DartEntry.IS_CLIENT);
             statistics.putCacheItem(dartEntry, DartEntry.IS_LAUNCHABLE);
           }
           List<Source> librarySources = getLibrariesContaining(source);
           for (Source librarySource in librarySources) {
@@ skipping 633 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 = _options.hint;
+      if (_incrementalAnalysisCache != null) {
+        AnalysisTask task = new IncrementalAnalysisTask(this, _incrementalAnalysisCache);
+        _incrementalAnalysisCache = null;
+      }
       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 506 matching lines @@
         }
       }
     }
     if (thrownException != null) {
       throw thrownException;
     }
     return libraryEntry;
   }
 
   /**
+   * Record the results produced by performing a [IncrementalAnalysisTask].
+   *
+   * @param task the task that was performed
+   * @return an entry containing the computed results
+   * @throws AnalysisException if the results could not be recorded
+   */
+  DartEntry recordIncrementalAnalysisTaskResults(IncrementalAnalysisTask task) {
+    {
+      CompilationUnit unit = task.compilationUnit;
+      if (unit != null) {
+        ChangeNoticeImpl notice = getNotice(task.source);
+        notice.compilationUnit = unit;
+      }
+    }
+    return null;
+  }
+
+  /**
    * Record the results produced by performing a [ParseDartTask]. If the results were computed
    * from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
    * @return an entry containing the computed results
    * @throws AnalysisException if the results could not be recorded
    */
   DartEntry recordParseDartTaskResults(ParseDartTask task) {
     Source source = task.source;
     AnalysisException thrownException = task.exception;
@@ skipping 433 matching lines @@
 }
 /**
  * Instances of the class `AnalysisTaskResultRecorder` are used by an analysis context to
  * record the results of a task.
  */
 class AnalysisContextImpl_AnalysisTaskResultRecorder implements AnalysisTaskVisitor<SourceEntry> {
   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);
+  SourceEntry visitIncrementalAnalysisTask(IncrementalAnalysisTask task) => AnalysisContextImpl_this.recordIncrementalAnalysisTaskResults(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) {
@@ skipping 1566 matching lines @@
   /**
    * Visit a [GenerateDartHintsTask].
    *
    * @param task the task to be visited
    * @return the result of visiting the task
    * @throws AnalysisException if the visitor throws an exception for some reason
    */
   E visitGenerateDartHintsTask(GenerateDartHintsTask task);
 
   /**
+   * Visit an [IncrementalAnalysisTask].
+   *
+   * @param task the task to be visited
+   * @return the result of visiting the task
+   * @throws AnalysisException if the visitor throws an exception for some reason
+   */
+  E visitIncrementalAnalysisTask(IncrementalAnalysisTask incrementalAnalysisTask);
+
+  /**
    * Visit a [ParseDartTask].
    *
    * @param task the task to be visited
    * @return the result of visiting the task
    * @throws AnalysisException if the visitor throws an exception for some reason
    */
   E visitParseDartTask(ParseDartTask task);
 
   /**
    * Visit a [ParseHtmlTask].
@@ skipping 163 matching lines @@
   /**
    * 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
    */
   TimestampedData<CompilationUnit> getCompilationUnit(Source unitSource) => context.internalResolveCompilationUnit(unitSource, libraryElement);
 }
 /**
+ * Instances of the class `IncrementalAnalysisTask` incrementally update existing analysis.
+ */
+class IncrementalAnalysisTask extends AnalysisTask {
+
+  /**
+   * The information used to perform incremental analysis.
+   */
+  IncrementalAnalysisCache _cache;
+
+  /**
+   * The compilation unit that was produced by incrementally updating the existing unit.
+   */
+  CompilationUnit compilationUnit;
+
+  /**
+   * Initialize a newly created task to perform analysis within the given context.
+   *
+   * @param context the context in which the task is to be performed
+   * @param cache the incremental analysis cache used to perform the analysis
+   */
+  IncrementalAnalysisTask(InternalAnalysisContext context, IncrementalAnalysisCache cache) : super(context) {
+    this._cache = cache;
+  }
+  accept(AnalysisTaskVisitor visitor) => visitor.visitIncrementalAnalysisTask(this);
+
+  /**
+   * Return the source that is to be incrementally analyzed.
+   *
+   * @return the source
+   */
+  Source get source => _cache != null ? _cache.source : null;
+  String get taskDescription => "incremental analysis ${(_cache != null ? _cache.source : "null")}";
+  void internalPerform() {
+    if (_cache == null) {
+      return;
+    }
+    compilationUnit = _cache.resolvedUnit;
+  }
+}
+/**
  * Instances of the class `ParseDartTask` parse a specific source as a Dart file.
  */
 class ParseDartTask extends AnalysisTask {
 
   /**
    * The source to be parsed.
    */
   Source source;
 
   /**
@@ skipping 593 matching lines @@
   }
   void logError2(String message, Exception exception) {
   }
   void logError3(Exception exception) {
   }
   void logInformation(String message) {
   }
   void logInformation2(String message, Exception exception) {
   }
 }