Version 0.8.10.1

dart/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 4036 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) {
+      if (_incrementalAnalysisCache != null && _incrementalAnalysisCache.hasWork()) {
         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()) {
@@ skipping 521 matching lines @@
    * @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;
+        _incrementalAnalysisCache = IncrementalAnalysisCache.cacheResult(task.cache, unit);
       }
     }
     return null;
   }
 
   /**
    * Record the results produced by performing a [ParseDartTask]. If the results were computed
    * from data that is now out-of-date, then the results will not be recorded.
    *
    * @param task the task that was performed
@@ skipping 30 matching lines @@
           } else {
             dartCopy.setValue(DartEntry.SOURCE_KIND, SourceKind.LIBRARY);
           }
           dartCopy.setValue(DartEntry.PARSED_UNIT, task.compilationUnit);
           dartCopy.setValue(DartEntry.PARSE_ERRORS, task.errors);
           dartCopy.setValue(DartEntry.EXPORTED_LIBRARIES, task.exportedSources);
           dartCopy.setValue(DartEntry.IMPORTED_LIBRARIES, task.importedSources);
           dartCopy.setValue(DartEntry.INCLUDED_PARTS, task.includedSources);
           ChangeNoticeImpl notice = getNotice(source);
           notice.setErrors(dartEntry.allErrors, lineInfo);
+          _incrementalAnalysisCache = IncrementalAnalysisCache.verifyStructure(_incrementalAnalysisCache, source, task.compilationUnit);
         } else {
           dartCopy.recordParseError();
         }
         dartCopy.exception = thrownException;
         _cache.put(source, dartCopy);
         dartEntry = dartCopy;
       } else {
         DartEntryImpl dartCopy = dartEntry.writableCopy;
         if (thrownException == null || resultTime >= 0) {
           dartCopy.recordParseNotInProcess();
@@ skipping 922 matching lines @@
 }
 /**
  * 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
+   * @param unit the incrementally updated compilation unit
+   * @return the cache used for incremental analysis or `null` if incremental analysis results
+   *         cannot be cached for the next incremental analysis
+   */
+  static IncrementalAnalysisCache cacheResult(IncrementalAnalysisCache cache, CompilationUnit unit) {
+    if (cache != null && unit != null) {
+      return new IncrementalAnalysisCache(cache.librarySource, cache.source, unit, cache.newContents, cache.newContents, 0, 0, 0);
+    }
+    return null;
+  }
+
+  /**
    * Determine if the cache should be cleared.
    *
    * @param cache the prior cache or `null` if none
    * @param source the source being updated (not `null`)
    * @return the cache used for incremental analysis or `null` if incremental analysis cannot
    *         be performed
    */
   static IncrementalAnalysisCache clear(IncrementalAnalysisCache cache, Source source) {
     if (cache == null || cache.source == source) {
       return null;
     }
     return cache;
   }
 
   /**
    * Determine if incremental analysis can be performed from the given information.
    *
    * @param cache the prior cache or `null` if none
    * @param source the source being updated (not `null`)
    * @param oldContents the original source contents prior to this update (not `null`)
    * @param newContents the new contents after this incremental change (not `null`)
    * @param offset the offset at which the change occurred
    * @param oldLength the length of the text being replaced
    * @param newLength the length of the replacement text
    * @param sourceEntry the cached entry for the given source or `null` if none
    * @return the cache used for incremental analysis or `null` if incremental analysis cannot
    *         be performed
    */
   static IncrementalAnalysisCache update(IncrementalAnalysisCache cache, Source source, String oldContents, String newContents, int offset, int oldLength, int newLength, SourceEntry sourceEntry) {
-    if (cache == null || cache.source != source) {
-      if (sourceEntry is! DartEntryImpl) {
-        return null;
-      }
+    Source librarySource = null;
+    CompilationUnit unit = null;
+    if (sourceEntry is DartEntryImpl) {
       DartEntryImpl dartEntry = sourceEntry as DartEntryImpl;
       List<Source> librarySources = dartEntry.librariesContaining;
-      if (librarySources.length != 1) {
-        return null;
+      if (librarySources.length == 1) {
+        librarySource = librarySources[0];
+        if (librarySource != null) {
+          unit = dartEntry.getValue2(DartEntry.RESOLVED_UNIT, librarySource);
+        }
       }
-      Source librarySource = librarySources[0];
-      if (librarySource == null) {
-        return null;
-      }
-      CompilationUnit unit = dartEntry.getValue2(DartEntry.RESOLVED_UNIT, librarySource);
+    }
+    if (cache == null || cache.source != source || unit != null) {
       if (unit == null) {
         return null;
       }
       if (oldContents == null) {
         if (oldLength != 0) {
           return null;
         }
         oldContents = "${newContents.substring(0, offset)}${newContents.substring(offset + newLength)}";
       }
       return new IncrementalAnalysisCache(librarySource, source, unit, oldContents, newContents, offset, oldLength, newLength);
     }
-    if (cache.offset > offset || offset > cache.offset + cache.newLength) {
-      return null;
+    if (cache.oldLength == 0 && cache.newLength == 0) {
+      cache.offset = offset;
+      cache.oldLength = oldLength;
+      cache.newLength = newLength;
+    } else {
+      if (cache.offset > offset || offset > cache.offset + cache.newLength) {
+        return null;
+      }
+      cache.newLength += newLength - oldLength;
     }
     cache.newContents = newContents;
-    cache.newLength += newLength - oldLength;
+    return cache;
+  }
+
+  /**
+   * Verify that the incrementally parsed and resolved unit in the incremental cache is structurally
+   * 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.equals3(cache.resolvedUnit, unit)) {
+        return null;
+      }
+    }
     return cache;
   }
   Source librarySource;
   Source source;
   String oldContents;
   CompilationUnit resolvedUnit;
   String newContents;
   int offset = 0;
   int oldLength = 0;
   int newLength = 0;
   IncrementalAnalysisCache(Source librarySource, Source source, CompilationUnit resolvedUnit, String oldContents, String newContents, int offset, int oldLength, int newLength) {
     this.librarySource = librarySource;
     this.source = source;
     this.resolvedUnit = resolvedUnit;
     this.oldContents = oldContents;
     this.newContents = newContents;
     this.offset = offset;
     this.oldLength = oldLength;
     this.newLength = newLength;
   }
+
+  /**
+   * Determine if the cache contains source changes that need to be analyzed
+   *
+   * @return `true` if the cache contains changes to be analyzed, else `false`
+   */
+  bool hasWork() => oldLength > 0 && newLength > 0;
 }
 /**
  * Instances of the class `InstrumentedAnalysisContextImpl` implement an
  * [AnalysisContext] by recording instrumentation data and delegating to
  * another analysis context to do the non-instrumentation work.
  *
  * @coverage dart.engine
  */
 class InstrumentedAnalysisContextImpl implements InternalAnalysisContext {
 
@@ skipping 1154 matching lines @@
   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;
+  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;
+    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")}";
+  Source get source => cache != null ? cache.source : null;
+  String get taskDescription => "incremental analysis ${(cache != null ? cache.source : "null")}";
   void internalPerform() {
-    if (_cache == null) {
+    if (cache == null) {
       return;
     }
-    compilationUnit = _cache.resolvedUnit;
+    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.
    */
@@ skipping 596 matching lines @@
   }
   void logError2(String message, Exception exception) {
   }
   void logError3(Exception exception) {
   }
   void logInformation(String message) {
   }
   void logInformation2(String message, Exception exception) {
   }
 }