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';
-import 'scanner.dart' show Token, Scanner, CharSequenceReader;
+import 'scanner.dart' show Token, Scanner, CharSequenceReader, CharacterReader, IncrementalScanner;
 import 'ast.dart';
-import 'parser.dart' show Parser;
+import 'parser.dart' show Parser, IncrementalParser;
 import 'sdk.dart' show DartSdk;
 import 'element.dart';
 import 'resolver.dart';
 import 'html.dart' show XmlTagNode, XmlAttributeNode, RecursiveXmlVisitor, HtmlScanner, HtmlScanResult, HtmlParser, HtmlParseResult, HtmlScriptTagNode, HtmlUnit;
 
 /**
  * The unique instance of the class `AnalysisEngine` serves as the entry point for the
  * functionality provided by the analysis engine.
  *
  * @coverage dart.engine
@@ skipping 658 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 `true` if analysis is to parse and analyze function bodies.
+   *
+   * @return `true` if analysis is to parse and analyzer function bodies
+   */
+  bool get analyzeFunctionBodies;
+
+  /**
    * 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 incremental analysis should be used.
+   *
+   * @return `true` if incremental analysis should be used
+   */
+  bool get incremental;
+
+  /**
+   * Return `true` if analysis is to parse comments.
+   *
+   * @return `true` if analysis is to parse comments
+   */
+  bool get preserveComments;
 }
 
 /**
  * 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.
    */
@@ skipping 2932 matching lines @@
     }
     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) {
     {
-      bool needsRecompute = this._options.dart2jsHint != options.dart2jsHint || (this._options.hint && !options.hint);
+      bool needsRecompute = this._options.analyzeFunctionBodies != options.analyzeFunctionBodies || 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;
         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.dart2jsHint = options.dart2jsHint;
       this._options.hint = options.hint;
+      this._options.incremental = options.incremental;
+      this._options.preserveComments = options.preserveComments;
       if (needsRecompute) {
         invalidateAllResolutionInformation();
       }
     }
   }
 
   void set analysisPriorityOrder(List<Source> sources) {
     {
       if (sources == null || sources.isEmpty) {
         _priorityOrder = Source.EMPTY_ARRAY;
@@ skipping 517 matching lines @@
    * 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 && _incrementalAnalysisCache.hasWork()) {
         AnalysisTask task = new IncrementalAnalysisTask(this, _incrementalAnalysisCache);
         _incrementalAnalysisCache = null;
+        if (_options.incremental) {
+          return task;
+        }
       }
       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) {
@@ skipping 1092 matching lines @@
    * The maximum number of sources for which data should be kept in the cache.
    */
   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 parse and analyze function bodies.
+   */
+  bool _analyzeFunctionBodies = true;
+
+  /**
    * 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 incremental analysis should be used.
+   */
+  bool _incremental = false;
+
+  /**
+   * flag indicating whether analysis is to parse comments.
+   */
+  bool _preserveComments = 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;
+    _incremental = options.incremental;
   }
 
+  bool get analyzeFunctionBodies => _analyzeFunctionBodies;
+
   int get cacheSize => _cacheSize;
 
   bool get dart2jsHint => _dart2jsHint;
 
   bool get hint => _hint;
 
+  bool get incremental => _incremental;
+
+  bool get preserveComments => _preserveComments;
+
+  /**
+   * Set whether analysis is to parse and analyze function bodies.
+   *
+   * @param analyzeFunctionBodies `true` if analysis is to parse and analyze function bodies
+   */
+  void set analyzeFunctionBodies(bool analyzeFunctionBodies) {
+    this._analyzeFunctionBodies = analyzeFunctionBodies;
+  }
+
   /**
    * 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
    * best practices).
    *
    * @param hint `true` if analysis is to generate hint results
    */
   void set hint(bool hint) {
     this._hint = hint;
   }
+
+  /**
+   * Set whether incremental analysis should be used.
+   *
+   * @param incremental `true` if incremental analysis should be used
+   */
+  void set incremental(bool incremental) {
+    this._incremental = incremental;
+  }
+
+  /**
+   * Set whether analysis is to parse comments.
+   *
+   * @param preserveComments `true` if analysis is to parse comments
+   */
+  void set preserveComments(bool preserveComments) {
+    this._preserveComments = preserveComments;
+  }
 }
 
 /**
  * Instances of the class `ChangeNoticeImpl` represent a change to the analysis results
  * associated with a given source.
  *
  * @coverage dart.engine
  */
 class ChangeNoticeImpl implements ChangeNotice {
   /**
@@ skipping 1794 matching lines @@
    * @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;
+    if (cache.oldLength > 0 || cache.newLength > 30) {
+      return;
+    }
+    CharacterReader reader = new CharSequenceReader(new CharSequence(cache.newContents));
+    BooleanErrorListener errorListener = new BooleanErrorListener();
+    IncrementalScanner scanner = new IncrementalScanner(cache.source, reader, errorListener);
+    Token oldTokens = cache.resolvedUnit.beginToken;
+    Token newTokens = scanner.rescan(oldTokens, cache.offset, cache.oldLength, cache.newLength);
+    if (errorListener.errorReported) {
+      return;
+    }
+    IncrementalParser parser = new IncrementalParser(cache.source, scanner.tokenMap, AnalysisErrorListener.NULL_LISTENER);
+    compilationUnit = parser.reparse(cache.resolvedUnit, scanner.leftToken, scanner.rightToken, cache.offset, cache.offset + cache.oldLength);
   }
 }
 
 /**
  * Instances of the class `ParseDartTask` parse a specific source as a Dart file.
  */
 class ParseDartTask extends AnalysisTask {
   /**
    * The source to be parsed.
    */
@@ skipping 114 matching lines @@
       } on JavaException catch (exception) {
         modificationTime = source.modificationStamp;
         throw new AnalysisException.con3(exception);
       }
     } finally {
       timeCounterScan.stop();
     }
     TimeCounter_TimeCounterHandle timeCounterParse = PerformanceStatistics.parse.start();
     try {
       Parser parser = new Parser(source, errorListener);
+      parser.parseFunctionBodies = context.analysisOptions.analyzeFunctionBodies;
       compilationUnit = parser.parseCompilationUnit(token[0]);
       errors = errorListener.getErrors2(source);
       for (Directive directive in compilationUnit.directives) {
         if (directive is ExportDirective) {
           Source exportSource = resolveSource(source, directive as ExportDirective);
           if (exportSource != null) {
             _exportedSources.add(exportSource);
           }
         } else if (directive is ImportDirective) {
           Source importSource = resolveSource(source, directive as ImportDirective);
@@ skipping 61 matching lines @@
 class Source_ContentReceiver_11 implements Source_ContentReceiver {
   final ParseDartTask ParseDartTask_this;
 
   RecordingErrorListener errorListener;
 
   List<Token> token;
 
   Source_ContentReceiver_11(this.ParseDartTask_this, this.errorListener, this.token);
 
   void accept(CharBuffer contents, int modificationTime) {
+    doScan(contents, modificationTime);
+  }
+
+  void accept2(String contents, int modificationTime) {
+    doScan(new CharSequence(contents), modificationTime);
+  }
+
+  void doScan(CharSequence contents, int modificationTime) {
     ParseDartTask_this.modificationTime = modificationTime;
     Scanner scanner = new Scanner(ParseDartTask_this.source, new CharSequenceReader(contents), errorListener);
+    scanner.preserveComments = ParseDartTask_this.context.analysisOptions.preserveComments;
     token[0] = scanner.tokenize();
     ParseDartTask_this.lineInfo = new LineInfo(scanner.lineStarts);
   }
-
-  void accept2(String contents, int modificationTime) {
-    ParseDartTask_this.modificationTime = modificationTime;
-    Scanner scanner = new Scanner(ParseDartTask_this.source, new CharSequenceReader(new CharSequence(contents)), errorListener);
-    token[0] = scanner.tokenize();
-    ParseDartTask_this.lineInfo = new LineInfo(scanner.lineStarts);
-  }
 }
 
 /**
  * Instances of the class `ParseHtmlTask` parse a specific source as an HTML file.
  */
 class ParseHtmlTask extends AnalysisTask {
   /**
    * The source to be parsed.
    */
   Source source;
@@ skipping 400 matching lines @@
 
   void logError3(Exception exception) {
   }
 
   void logInformation(String message) {
   }
 
   void logInformation2(String message, Exception exception) {
   }
 }