New analyzer snapshot.

pkg/analyzer/lib/src/generated/parser.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.parser;
 
 import 'dart:collection';
 import 'java_core.dart';
 import 'instrumentation.dart';
 import 'error.dart';
 import 'source.dart';
 import 'scanner.dart';
 import 'ast.dart';
 import 'utilities_dart.dart';
 import 'engine.dart' show AnalysisEngine;
 import 'utilities_collection.dart' show TokenMap;
 
 /**
  * Instances of the class `CommentAndMetadata` implement a simple data-holder for a method
  * that needs to return multiple values.
  *
  * @coverage dart.engine.parser
  */
 class CommentAndMetadata {
   /**
    * The documentation comment that was parsed, or `null` if none was given.
    */
-  Comment comment;
+  final Comment comment;
 
   /**
    * The metadata that was parsed.
    */
-  List<Annotation> metadata;
+  final List<Annotation> metadata;
 
   /**
    * Initialize a newly created holder with the given data.
    *
    * @param comment the documentation comment that was parsed
    * @param metadata the metadata that was parsed
    */
-  CommentAndMetadata(Comment comment, List<Annotation> metadata) {
-    this.comment = comment;
-    this.metadata = metadata;
-  }
+  CommentAndMetadata(this.comment, this.metadata);
 }
 
 /**
  * Instances of the class `FinalConstVarOrType` implement a simple data-holder for a method
  * that needs to return multiple values.
  *
  * @coverage dart.engine.parser
  */
 class FinalConstVarOrType {
   /**
    * The 'final', 'const' or 'var' keyword, or `null` if none was given.
    */
-  Token keyword;
+  final Token keyword;
 
   /**
    * The type, of `null` if no type was specified.
    */
-  TypeName type;
+  final TypeName type;
 
   /**
    * Initialize a newly created holder with the given data.
    *
    * @param keyword the 'final', 'const' or 'var' keyword
    * @param type the type
    */
-  FinalConstVarOrType(Token keyword, TypeName type) {
-    this.keyword = keyword;
-    this.type = type;
-  }
+  FinalConstVarOrType(this.keyword, this.type);
 }
 
 /**
  * Instances of the class `Modifiers` implement a simple data-holder for a method that needs
  * to return multiple values.
  *
  * @coverage dart.engine.parser
  */
 class Modifiers {
   /**
@@ skipping 1058 matching lines @@
    * A map from old tokens to new tokens used during the cloning process.
    */
   TokenMap _tokenMap;
 
   /**
    * The error listener that will be informed of any errors that are found during the parse.
    */
   AnalysisErrorListener _errorListener;
 
   /**
+   * The node in the AST structure that contains the revised content.
+   */
+  ASTNode _updatedNode;
+
+  /**
    * Initialize a newly created incremental parser to parse a portion of the content of the given
    * source.
    *
    * @param source the source being parsed
    * @param tokenMap a map from old tokens to new tokens used during the cloning process
    * @param errorListener the error listener that will be informed of any errors that are found
    *          during the parse
    */
   IncrementalParser(Source source, TokenMap tokenMap, AnalysisErrorListener errorListener) {
     this._source = source;
     this._tokenMap = tokenMap;
     this._errorListener = errorListener;
   }
 
   /**
+   * Return the node in the AST structure that contains the revised content.
+   *
+   * @return the updated node
+   */
+  ASTNode get updatedNode => _updatedNode;
+
+  /**
    * Given a range of tokens that were re-scanned, re-parse the minimum number of tokens to produce
    * a consistent AST structure. The range is represented by the first and last tokens in the range.
    * The tokens are assumed to be contained in the same token stream.
    *
    * @param leftToken the token in the new token stream immediately to the left of the range of
    *          tokens that were inserted
    * @param rightToken the token in the new token stream immediately to the right of the range of
    *          tokens that were inserted
    * @param originalStart the offset in the original source of the first character that was modified
    * @param originalEnd the offset in the original source of the last character that was modified
@@ skipping 38 matching lines @@
         return null;
       }
       if (advanceToParent) {
         newNode = null;
         oldNode = parent;
         originalOffset = oldNode.offset;
         parseToken = findTokenAt(parseToken, originalOffset);
         parser.currentToken = parseToken;
       }
     }
+    _updatedNode = newNode;
     if (identical(oldNode, originalStructure)) {
       ResolutionCopier.copyResolutionData(oldNode, newNode);
       return newNode as ASTNode;
     }
     ResolutionCopier.copyResolutionData(oldNode, newNode);
     IncrementalASTCloner cloner = new IncrementalASTCloner(oldNode, newNode, _tokenMap);
     return originalStructure.accept(cloner) as ASTNode;
   }
 
   /**
@@ skipping 14 matching lines @@
    * no such token.
    *
    * @param firstToken the token from which the search is to begin
    * @param offset the offset of the token to be returned
    * @return the token with the given offset
    */
   Token findTokenAt(Token firstToken, int offset) {
     while (firstToken.offset > offset && firstToken.type != TokenType.EOF) {
       firstToken = firstToken.previous;
     }
-    if (firstToken.offset == offset) {
-      return firstToken;
-    }
-    return null;
+    return firstToken;
   }
 }
 
 /**
  * Instances of the class `InsufficientContextException` represent a situation in which an AST
  * node cannot be re-parsed because there is not enough context to know how to re-parse the node.
  * Clients can attempt to re-parse the parent of the node.
  */
 class InsufficientContextException extends IncrementalParseException {
   /**
@@ skipping 8020 matching lines @@
       if ("\n" == separator) {
         _writer.print("\n");
         indent();
       } else if (i > 0) {
         _writer.print(separator);
       }
       _writer.print(tokens[i].lexeme);
     }
   }
 }