New analyzer snapshot.

pkg/analyzer/lib/src/generated/scanner.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.scanner;
 
 import 'dart:collection';
 import 'java_core.dart';
 import 'java_engine.dart';
 import 'source.dart';
 import 'error.dart';
@@ skipping 508 matching lines @@
     }
     return _sequence.charAt(_charOffset + 1);
   }
 
   void set offset(int offset) {
     _charOffset = offset;
   }
 }
 
 /**
+ * Synthetic `StringToken` represent a token whose value is independent of it's type.
+ *
+ * @coverage dart.engine.parser
+ */
+class SyntheticStringToken extends StringToken {
+  /**
+   * Initialize a newly created token to represent a token of the given type with the given value.
+   *
+   * @param type the type of the token
+   * @param value the lexeme represented by this token
+   * @param offset the offset from the beginning of the file to the first character in the token
+   */
+  SyntheticStringToken(TokenType type, String value, int offset) : super(type, value, offset);
+
+  bool get isSynthetic => true;
+}
+
+/**
  * Instances of the class `IncrementalScanner` implement a scanner that scans a subset of a
  * string and inserts the resulting tokens into the middle of an existing token stream.
  *
  * @coverage dart.engine.parser
  */
 class IncrementalScanner extends Scanner {
   /**
    * The reader used to access the characters in the source.
    */
   CharacterReader _reader;
 
   /**
    * A map from tokens that were copied to the copies of the tokens.
    */
   final TokenMap tokenMap = new TokenMap();
 
   /**
-   * The first token in the range of tokens that are different from the tokens in the original token
-   * stream.
+   * The token in the new token stream immediately to the left of the range of tokens that were
+   * inserted, or the token immediately to the left of the modified region if there were no new
+   * tokens.
    */
-  Token _firstToken;
+  Token leftToken;
 
   /**
-   * The last token in the range of tokens that are different from the tokens in the original token
-   * stream.
+   * The token in the new token stream immediately to the right of the range of tokens that were
+   * inserted, or the token immediately to the right of the modified region if there were no new
+   * tokens.
    */
-  Token lastToken;
+  Token rightToken;
+
+  /**
+   * A flag indicating whether there were any tokens changed as a result of the modification.
+   */
+  bool _hasNonWhitespaceChange2 = false;
 
   /**
    * Initialize a newly created scanner.
    *
    * @param source the source being scanned
    * @param reader the character reader used to read the characters in the source
    * @param errorListener the error listener that will be informed of any errors that are found
    */
   IncrementalScanner(Source source, CharacterReader reader, AnalysisErrorListener errorListener) : super(source, reader, errorListener) {
     this._reader = reader;
   }
 
   /**
-   * Return the first token in the range of tokens that are different from the tokens in the
-   * original token stream or `null` if the new tokens are the same as the original tokens
-   * except for offset.
+   * Return `true` if there were any tokens either added or removed (or both) as a result of
+   * the modification.
    *
-   * @return the first token in the range of new tokens
+   * @return `true` if there were any tokens changed as a result of the modification
    */
-  Token get firstToken => _firstToken;
+  bool hasNonWhitespaceChange() => _hasNonWhitespaceChange2;
 
   /**
    * Given the stream of tokens scanned from the original source, the modified source (the result of
    * replacing one contiguous range of characters with another string of characters), and a
    * specification of the modification that was made, return a stream of tokens scanned from the
    * modified source. The original stream of tokens will not be modified.
    *
    * @param originalStream the stream of tokens scanned from the original source
    * @param index the index of the first character in both the original and modified source that was
    *          affected by the modification
    * @param removedLength the number of characters removed from the original source
    * @param insertedLength the number of characters added to the modified source
    */
   Token rescan(Token originalStream, int index, int removedLength, int insertedLength) {
     while (originalStream.type != TokenType.EOF && originalStream.end < index) {
       originalStream = copyAndAdvance(originalStream, 0);
     }
-    Token lastCopied = tail;
-    int modifiedEnd = index + insertedLength - 1;
-    if (originalStream.offset < index) {
-      modifiedEnd += originalStream.end - index - removedLength;
+    Token oldFirst = originalStream;
+    Token oldLeftToken = originalStream.previous;
+    leftToken = tail;
+    int removedEnd = index + (removedLength == 0 ? 0 : removedLength - 1);
+    while (originalStream.type != TokenType.EOF && originalStream.offset <= removedEnd) {
+      originalStream = originalStream.next;
     }
-    _reader.offset = Math.min(originalStream.offset, index) - 1;
+    Token oldLast;
+    Token oldRightToken;
+    if (originalStream.type != TokenType.EOF && removedEnd + 1 == originalStream.offset) {
+      oldLast = originalStream;
+      originalStream = originalStream.next;
+      oldRightToken = originalStream;
+    } else {
+      oldLast = originalStream.previous;
+      oldRightToken = originalStream;
+    }
+    int delta = insertedLength - removedLength;
+    int scanStart = Math.min(oldFirst.offset, index);
+    int oldEnd = oldLast.end + delta - 1;
+    int newEnd = index + insertedLength - 1;
+    int scanEnd = Math.max(newEnd, oldEnd);
+    _reader.offset = scanStart - 1;
     int next = _reader.advance();
-    while (next != -1 && _reader.offset <= modifiedEnd) {
+    while (next != -1 && _reader.offset <= scanEnd) {
       next = bigSwitch(next);
     }
-    _firstToken = lastCopied.next;
-    lastToken = tail;
-    if (_firstToken == null || identical(_firstToken.type, TokenType.EOF)) {
-      _firstToken = null;
-      lastToken = null;
-    } else if (originalStream.end == index && _firstToken.end == index) {
-      tokenMap.put(originalStream, _firstToken);
-      if (identical(lastToken, _firstToken)) {
-        lastToken = lastToken.next;
+    if (identical(originalStream.type, TokenType.EOF)) {
+      copyAndAdvance(originalStream, delta);
+      rightToken = tail;
+      rightToken.setNextWithoutSettingPrevious(rightToken);
+    } else {
+      originalStream = copyAndAdvance(originalStream, delta);
+      rightToken = tail;
+      while (originalStream.type != TokenType.EOF) {
+        originalStream = copyAndAdvance(originalStream, delta);
       }
-      _firstToken = _firstToken.next;
+      Token eof = copyAndAdvance(originalStream, delta);
+      eof.setNextWithoutSettingPrevious(eof);
     }
-    int removedEnd = index + removedLength - 1 + Math.max(0, tail.end - index - insertedLength);
-    while (originalStream.offset <= removedEnd) {
-      originalStream = originalStream.next;
+    Token newFirst = leftToken.next;
+    while (newFirst != rightToken && oldFirst != oldRightToken && newFirst.type != TokenType.EOF && equals3(oldFirst, newFirst)) {
+      tokenMap.put(oldFirst, newFirst);
+      oldLeftToken = oldFirst;
+      oldFirst = oldFirst.next;
+      leftToken = newFirst;
+      newFirst = newFirst.next;
     }
-    int delta = insertedLength - removedLength;
-    while (originalStream.type != TokenType.EOF) {
-      originalStream = copyAndAdvance(originalStream, delta);
+    Token newLast = rightToken.previous;
+    while (newLast != leftToken && oldLast != oldLeftToken && newLast.type != TokenType.EOF && equals3(oldLast, newLast)) {
+      tokenMap.put(oldLast, newLast);
+      oldRightToken = oldLast;
+      oldLast = oldLast.previous;
+      rightToken = newLast;
+      newLast = newLast.previous;
     }
-    Token eof = copyAndAdvance(originalStream, delta);
-    eof.setNextWithoutSettingPrevious(eof);
-    return super.firstToken;
+    _hasNonWhitespaceChange2 = leftToken.next != rightToken || oldLeftToken.next != oldRightToken;
+    return firstToken;
   }
 
   Token copyAndAdvance(Token originalToken, int delta) {
     Token copiedToken = originalToken.copy();
     tokenMap.put(originalToken, copiedToken);
     copiedToken.applyDelta(delta);
     appendToken(copiedToken);
     Token originalComment = originalToken.precedingComments;
     Token copiedComment = originalToken.precedingComments;
     while (originalComment != null) {
       tokenMap.put(originalComment, copiedComment);
       originalComment = originalComment.next;
       copiedComment = copiedComment.next;
     }
     return originalToken.next;
   }
+
+  /**
+   * Return `true` if the two tokens are equal to each other. For the purposes of the
+   * incremental scanner, two tokens are equal if they have the same type and lexeme.
+   *
+   * @param oldToken the token from the old stream that is being compared
+   * @param newToken the token from the new stream that is being compared
+   * @return `true` if the two tokens are equal to each other
+   */
+  bool equals3(Token oldToken, Token newToken) => identical(oldToken.type, newToken.type) && oldToken.length == newToken.length && oldToken.lexeme == newToken.lexeme;
 }
 
 /**
  * The class `Scanner` implements a scanner for Dart code.
  *
  * The lexical structure of Dart is ambiguous without knowledge of the context in which a token is
  * being scanned. For example, without context we cannot determine whether source of the form "<<"
  * should be scanned as a single left-shift operator or as two left angle brackets. This scanner
  * does not have any context, so it always resolves such conflicts by scanning the longest possible
  * token.
@@ skipping 1164 matching lines @@
 
   /**
    * Return `true` if this token represents an operator.
    *
    * @return `true` if this token represents an operator
    */
   bool get isOperator => type.isOperator;
 
   /**
    * Return `true` if this token is a synthetic token. A synthetic token is a token that was
-   * introduced by the parser in order to recover from an error in the code. Synthetic tokens always
-   * have a length of zero (`0`).
+   * introduced by the parser in order to recover from an error in the code.
    *
    * @return `true` if this token is a synthetic token
    */
   bool get isSynthetic => length == 0;
 
   /**
    * Return `true` if this token represents an operator that can be defined by users.
    *
    * @return `true` if this token represents an operator that can be defined by users
    */
@@ skipping 220 matching lines @@
   static final TokenClass ADDITIVE_OPERATOR = new TokenClass.con2('ADDITIVE_OPERATOR', 1, 12);
 
   /**
    * A value used to indicate that the token type is an assignment operator.
    */
   static final TokenClass ASSIGNMENT_OPERATOR = new TokenClass.con2('ASSIGNMENT_OPERATOR', 2, 1);
 
   /**
    * A value used to indicate that the token type is a bitwise-and operator.
    */
-  static final TokenClass BITWISE_AND_OPERATOR = new TokenClass.con2('BITWISE_AND_OPERATOR', 3, 8);
+  static final TokenClass BITWISE_AND_OPERATOR = new TokenClass.con2('BITWISE_AND_OPERATOR', 3, 10);
 
   /**
    * A value used to indicate that the token type is a bitwise-or operator.
    */
-  static final TokenClass BITWISE_OR_OPERATOR = new TokenClass.con2('BITWISE_OR_OPERATOR', 4, 6);
+  static final TokenClass BITWISE_OR_OPERATOR = new TokenClass.con2('BITWISE_OR_OPERATOR', 4, 8);
 
   /**
    * A value used to indicate that the token type is a bitwise-xor operator.
    */
-  static final TokenClass BITWISE_XOR_OPERATOR = new TokenClass.con2('BITWISE_XOR_OPERATOR', 5, 7);
+  static final TokenClass BITWISE_XOR_OPERATOR = new TokenClass.con2('BITWISE_XOR_OPERATOR', 5, 9);
 
   /**
    * A value used to indicate that the token type is a cascade operator.
    */
   static final TokenClass CASCADE_OPERATOR = new TokenClass.con2('CASCADE_OPERATOR', 6, 2);
 
   /**
    * A value used to indicate that the token type is a conditional operator.
    */
   static final TokenClass CONDITIONAL_OPERATOR = new TokenClass.con2('CONDITIONAL_OPERATOR', 7, 3);
 
   /**
    * A value used to indicate that the token type is an equality operator.
    */
-  static final TokenClass EQUALITY_OPERATOR = new TokenClass.con2('EQUALITY_OPERATOR', 8, 9);
+  static final TokenClass EQUALITY_OPERATOR = new TokenClass.con2('EQUALITY_OPERATOR', 8, 6);
 
   /**
    * A value used to indicate that the token type is a logical-and operator.
    */
   static final TokenClass LOGICAL_AND_OPERATOR = new TokenClass.con2('LOGICAL_AND_OPERATOR', 9, 5);
 
   /**
    * A value used to indicate that the token type is a logical-or operator.
    */
   static final TokenClass LOGICAL_OR_OPERATOR = new TokenClass.con2('LOGICAL_OR_OPERATOR', 10, 4);
 
   /**
    * A value used to indicate that the token type is a multiplicative operator.
    */
   static final TokenClass MULTIPLICATIVE_OPERATOR = new TokenClass.con2('MULTIPLICATIVE_OPERATOR', 11, 13);
 
   /**
    * A value used to indicate that the token type is a relational operator.
    */
-  static final TokenClass RELATIONAL_OPERATOR = new TokenClass.con2('RELATIONAL_OPERATOR', 12, 10);
+  static final TokenClass RELATIONAL_OPERATOR = new TokenClass.con2('RELATIONAL_OPERATOR', 12, 7);
 
   /**
    * A value used to indicate that the token type is a shift operator.
    */
   static final TokenClass SHIFT_OPERATOR = new TokenClass.con2('SHIFT_OPERATOR', 13, 11);
 
   /**
    * A value used to indicate that the token type is a unary operator.
    */
   static final TokenClass UNARY_POSTFIX_OPERATOR = new TokenClass.con2('UNARY_POSTFIX_OPERATOR', 14, 15);
@@ skipping 403 matching lines @@
    * @return `true` if this token type represents an operator that can be defined by users
    */
   bool get isUserDefinableOperator => identical(lexeme, "==") || identical(lexeme, "~") || identical(lexeme, "[]") || identical(lexeme, "[]=") || identical(lexeme, "*") || identical(lexeme, "/") || identical(lexeme, "%") || identical(lexeme, "~/") || identical(lexeme, "+") || identical(lexeme, "-") || identical(lexeme, "<<") || identical(lexeme, ">>") || identical(lexeme, ">=") || identical(lexeme, ">") || identical(lexeme, "<=") || identical(lexeme, "<") || identical(lexeme, "&") || identical(lexeme, "^") || identical(lexeme, "|");
 }
 
 class TokenType_EOF extends TokenType {
   TokenType_EOF(String name, int ordinal, TokenClass arg0, String arg1) : super.con2(name, ordinal, arg0, arg1);
 
   String toString() => "-eof-";
 }