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';
 import 'instrumentation.dart';
 import 'utilities_collection.dart' show TokenMap;
+
 /**
  * Instances of the abstract class `KeywordState` represent a state in a state machine used to
  * scan keywords.
  *
  * @coverage dart.engine.parser
  */
 class KeywordState {
-
   /**
    * An empty transition table used by leaf states.
    */
   static List<KeywordState> _EMPTY_TABLE = new List<KeywordState>(26);
 
   /**
    * The initial state in the state machine.
    */
   static KeywordState KEYWORD_STATE = createKeywordStateTable();
 
@@ skipping 94 matching lines @@
 
   /**
    * Return the state that follows this state on a transition of the given character, or
    * `null` if there is no valid state reachable from this state with such a transition.
    *
    * @param c the character used to transition from this state to another state
    * @return the state that follows this state on a transition of the given character
    */
   KeywordState next(int c) => _table[c - 0x61];
 }
+
 /**
  * The enumeration `ScannerErrorCode` defines the error codes used for errors detected by the
  * scanner.
  *
  * @coverage dart.engine.parser
  */
 class ScannerErrorCode extends Enum<ScannerErrorCode> implements ErrorCode {
   static final ScannerErrorCode ILLEGAL_CHARACTER = new ScannerErrorCode.con1('ILLEGAL_CHARACTER', 0, "Illegal character %x");
+
   static final ScannerErrorCode MISSING_DIGIT = new ScannerErrorCode.con1('MISSING_DIGIT', 1, "Decimal digit expected");
+
   static final ScannerErrorCode MISSING_HEX_DIGIT = new ScannerErrorCode.con1('MISSING_HEX_DIGIT', 2, "Hexidecimal digit expected");
+
   static final ScannerErrorCode MISSING_QUOTE = new ScannerErrorCode.con1('MISSING_QUOTE', 3, "Expected quote (' or \")");
+
   static final ScannerErrorCode UNTERMINATED_MULTI_LINE_COMMENT = new ScannerErrorCode.con1('UNTERMINATED_MULTI_LINE_COMMENT', 4, "Unterminated multi-line comment");
+
   static final ScannerErrorCode UNTERMINATED_STRING_LITERAL = new ScannerErrorCode.con1('UNTERMINATED_STRING_LITERAL', 5, "Unterminated string literal");
+
   static final List<ScannerErrorCode> values = [
       ILLEGAL_CHARACTER,
       MISSING_DIGIT,
       MISSING_HEX_DIGIT,
       MISSING_QUOTE,
       UNTERMINATED_MULTI_LINE_COMMENT,
       UNTERMINATED_STRING_LITERAL];
 
   /**
    * The template used to create the message to be displayed for this error.
@@ skipping 18 matching lines @@
   /**
    * Initialize a newly created error code to have the given message and correction.
    *
    * @param message the template used to create the message to be displayed for the error
    * @param correction the template used to create the correction to be displayed for the error
    */
   ScannerErrorCode.con2(String name, int ordinal, String message, String correction) : super(name, ordinal) {
     this._message = message;
     this.correction10 = correction;
   }
+
   String get correction => correction10;
+
   ErrorSeverity get errorSeverity => ErrorSeverity.ERROR;
+
   String get message => _message;
+
   ErrorType get type => ErrorType.SYNTACTIC_ERROR;
 }
+
 /**
  * Instances of the class `SubSequenceReader` implement a [CharacterReader] that reads
  * characters from a character sequence, but adds a delta when reporting the current character
  * offset so that the character sequence can be a subsequence from a larger sequence.
  */
 class SubSequenceReader extends CharSequenceReader {
-
   /**
    * The offset from the beginning of the file to the beginning of the source being scanned.
    */
   int _offsetDelta = 0;
 
   /**
    * Initialize a newly created reader to read the characters in the given sequence.
    *
    * @param sequence the sequence from which characters will be read
    * @param offsetDelta the offset from the beginning of the file to the beginning of the source
    *          being scanned
    */
   SubSequenceReader(CharSequence sequence, int offsetDelta) : super(sequence) {
     this._offsetDelta = offsetDelta;
   }
+
   int get offset => _offsetDelta + super.offset;
+
   String getString(int start, int endDelta) => super.getString(start - _offsetDelta, endDelta);
+
   void set offset(int offset) {
     super.offset = offset - _offsetDelta;
   }
 }
+
 /**
  * Instances of the class `TokenWithComment` represent a string token that is preceded by
  * comments.
  *
  * @coverage dart.engine.parser
  */
 class StringTokenWithComment extends StringToken {
-
   /**
    * The first comment in the list of comments that precede this token.
    */
   Token _precedingComment;
 
   /**
    * Initialize a newly created token to have the given type and offset and to be preceded by the
    * comments reachable from the given comment.
    *
    * @param type the type of the token
    * @param offset the offset from the beginning of the file to the first character in the token
    * @param precedingComment the first comment in the list of comments that precede this token
    */
   StringTokenWithComment(TokenType type, String value, int offset, Token precedingComment) : super(type, value, offset) {
     this._precedingComment = precedingComment;
   }
+
   Token copy() => new StringTokenWithComment(type, lexeme, offset, copyComments(_precedingComment));
+
   Token get precedingComments => _precedingComment;
+
   void applyDelta(int delta) {
     super.applyDelta(delta);
     Token token = _precedingComment;
     while (token != null) {
       token.applyDelta(delta);
       token = token.next;
     }
   }
 }
+
 /**
  * The enumeration `Keyword` defines the keywords in the Dart programming language.
  *
  * @coverage dart.engine.parser
  */
 class Keyword extends Enum<Keyword> {
   static final Keyword ASSERT = new Keyword.con1('ASSERT', 0, "assert");
+
   static final Keyword BREAK = new Keyword.con1('BREAK', 1, "break");
+
   static final Keyword CASE = new Keyword.con1('CASE', 2, "case");
+
   static final Keyword CATCH = new Keyword.con1('CATCH', 3, "catch");
+
   static final Keyword CLASS = new Keyword.con1('CLASS', 4, "class");
+
   static final Keyword CONST = new Keyword.con1('CONST', 5, "const");
+
   static final Keyword CONTINUE = new Keyword.con1('CONTINUE', 6, "continue");
+
   static final Keyword DEFAULT = new Keyword.con1('DEFAULT', 7, "default");
+
   static final Keyword DO = new Keyword.con1('DO', 8, "do");
+
   static final Keyword ELSE = new Keyword.con1('ELSE', 9, "else");
+
   static final Keyword ENUM = new Keyword.con1('ENUM', 10, "enum");
+
   static final Keyword EXTENDS = new Keyword.con1('EXTENDS', 11, "extends");
+
   static final Keyword FALSE = new Keyword.con1('FALSE', 12, "false");
+
   static final Keyword FINAL = new Keyword.con1('FINAL', 13, "final");
+
   static final Keyword FINALLY = new Keyword.con1('FINALLY', 14, "finally");
+
   static final Keyword FOR = new Keyword.con1('FOR', 15, "for");
+
   static final Keyword IF = new Keyword.con1('IF', 16, "if");
+
   static final Keyword IN = new Keyword.con1('IN', 17, "in");
+
   static final Keyword IS = new Keyword.con1('IS', 18, "is");
+
   static final Keyword NEW = new Keyword.con1('NEW', 19, "new");
+
   static final Keyword NULL = new Keyword.con1('NULL', 20, "null");
+
   static final Keyword RETHROW = new Keyword.con1('RETHROW', 21, "rethrow");
+
   static final Keyword RETURN = new Keyword.con1('RETURN', 22, "return");
+
   static final Keyword SUPER = new Keyword.con1('SUPER', 23, "super");
+
   static final Keyword SWITCH = new Keyword.con1('SWITCH', 24, "switch");
+
   static final Keyword THIS = new Keyword.con1('THIS', 25, "this");
+
   static final Keyword THROW = new Keyword.con1('THROW', 26, "throw");
+
   static final Keyword TRUE = new Keyword.con1('TRUE', 27, "true");
+
   static final Keyword TRY = new Keyword.con1('TRY', 28, "try");
+
   static final Keyword VAR = new Keyword.con1('VAR', 29, "var");
+
   static final Keyword VOID = new Keyword.con1('VOID', 30, "void");
+
   static final Keyword WHILE = new Keyword.con1('WHILE', 31, "while");
+
   static final Keyword WITH = new Keyword.con1('WITH', 32, "with");
+
   static final Keyword ABSTRACT = new Keyword.con2('ABSTRACT', 33, "abstract", true);
+
   static final Keyword AS = new Keyword.con2('AS', 34, "as", true);
+
   static final Keyword DYNAMIC = new Keyword.con2('DYNAMIC', 35, "dynamic", true);
+
   static final Keyword EXPORT = new Keyword.con2('EXPORT', 36, "export", true);
+
   static final Keyword EXTERNAL = new Keyword.con2('EXTERNAL', 37, "external", true);
+
   static final Keyword FACTORY = new Keyword.con2('FACTORY', 38, "factory", true);
+
   static final Keyword GET = new Keyword.con2('GET', 39, "get", true);
+
   static final Keyword IMPLEMENTS = new Keyword.con2('IMPLEMENTS', 40, "implements", true);
+
   static final Keyword IMPORT = new Keyword.con2('IMPORT', 41, "import", true);
+
   static final Keyword LIBRARY = new Keyword.con2('LIBRARY', 42, "library", true);
+
   static final Keyword OPERATOR = new Keyword.con2('OPERATOR', 43, "operator", true);
+
   static final Keyword PART = new Keyword.con2('PART', 44, "part", true);
+
   static final Keyword SET = new Keyword.con2('SET', 45, "set", true);
+
   static final Keyword STATIC = new Keyword.con2('STATIC', 46, "static", true);
+
   static final Keyword TYPEDEF = new Keyword.con2('TYPEDEF', 47, "typedef", true);
+
   static final List<Keyword> values = [
       ASSERT,
       BREAK,
       CASE,
       CATCH,
       CLASS,
       CONST,
       CONTINUE,
       DEFAULT,
       DO,
@@ skipping 79 matching lines @@
    * the given flag is `true`.
    *
    * @param syntax the lexeme for the keyword
    * @param isPseudoKeyword `true` if this keyword is a pseudo-keyword
    */
   Keyword.con2(String name, int ordinal, String syntax, bool isPseudoKeyword) : super(name, ordinal) {
     this.syntax = syntax;
     this.isPseudoKeyword = isPseudoKeyword;
   }
 }
+
 /**
  * Instances of the class `CharSequenceReader` implement a [CharacterReader] that reads
  * characters from a character sequence.
  */
 class CharSequenceReader implements CharacterReader {
-
   /**
    * The sequence from which characters will be read.
    */
   CharSequence _sequence;
 
   /**
    * The number of characters in the string.
    */
   int _stringLength = 0;
 
   /**
    * The index, relative to the string, of the last character that was read.
    */
   int _charOffset = 0;
 
   /**
    * Initialize a newly created reader to read the characters in the given sequence.
    *
    * @param sequence the sequence from which characters will be read
    */
   CharSequenceReader(CharSequence sequence) {
     this._sequence = sequence;
     this._stringLength = sequence.length();
     this._charOffset = -1;
   }
+
   int advance() {
     if (_charOffset + 1 >= _stringLength) {
       return -1;
     }
     return _sequence.charAt(++_charOffset);
   }
+
   int get offset => _charOffset;
+
   String getString(int start, int endDelta) => _sequence.subSequence(start, _charOffset + 1 + endDelta).toString();
+
   int peek() {
     if (_charOffset + 1 >= _sequence.length()) {
       return -1;
     }
     return _sequence.charAt(_charOffset + 1);
   }
+
   void set offset(int offset) {
     _charOffset = offset;
   }
 }
+
 /**
  * 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();
 
@@ skipping 72 matching lines @@
       originalStream = originalStream.next;
     }
     int delta = insertedLength - removedLength;
     while (originalStream.type != TokenType.EOF) {
       originalStream = copyAndAdvance(originalStream, delta);
     }
     Token eof = copyAndAdvance(originalStream, delta);
     eof.setNextWithoutSettingPrevious(eof);
     return super.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;
   }
 }
+
 /**
  * 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.
  *
  * @coverage dart.engine.parser
  */
 class Scanner {
-
   /**
    * The source being scanned.
    */
   Source source;
 
   /**
    * The reader used to access the characters in the source.
    */
   CharacterReader _reader;
 
@@ skipping 127 matching lines @@
   /**
    * Append the given token to the end of the token stream being scanned. This method is intended to
    * be used by subclasses that copy existing tokens and should not normally be used because it will
    * fail to correctly associate any comments with the token being passed in.
    *
    * @param token the token to be appended
    */
   void appendToken(Token token) {
     tail = tail.setNext(token);
   }
+
   int bigSwitch(int next) {
     beginToken();
     if (next == 0xD) {
       next = _reader.advance();
       if (next == 0xA) {
         next = _reader.advance();
       }
       recordStartOfLine();
       return next;
     } else if (next == 0xA) {
@@ skipping 134 matching lines @@
    * @return the first token in the token stream that was scanned
    */
   Token get firstToken => _tokens.next;
 
   /**
    * Record the fact that we are at the beginning of a new line in the source.
    */
   void recordStartOfLine() {
     _lineStarts.add(_reader.offset);
   }
+
   void appendBeginToken(TokenType type) {
     BeginToken token;
     if (_firstComment == null) {
       token = new BeginToken(type, _tokenStart);
     } else {
       token = new BeginTokenWithComment(type, _tokenStart, _firstComment);
       _firstComment = null;
       _lastComment = null;
     }
     tail = tail.setNext(token);
     _groupingStack.add(token);
     _stackEnd++;
   }
+
   void appendCommentToken(TokenType type, String value) {
     if (_firstComment == null) {
       _firstComment = new StringToken(type, value, _tokenStart);
       _lastComment = _firstComment;
     } else {
       _lastComment = _lastComment.setNext(new StringToken(type, value, _tokenStart));
     }
   }
+
   void appendEndToken(TokenType type, TokenType beginType) {
     Token token;
     if (_firstComment == null) {
       token = new Token(type, _tokenStart);
     } else {
       token = new TokenWithComment(type, _tokenStart, _firstComment);
       _firstComment = null;
       _lastComment = null;
     }
     tail = tail.setNext(token);
     if (_stackEnd >= 0) {
       BeginToken begin = _groupingStack[_stackEnd];
       if (identical(begin.type, beginType)) {
         begin.endToken = token;
         _groupingStack.removeAt(_stackEnd--);
       }
     }
   }
+
   void appendEofToken() {
     Token eofToken;
     if (_firstComment == null) {
       eofToken = new Token(TokenType.EOF, _reader.offset + 1);
     } else {
       eofToken = new TokenWithComment(TokenType.EOF, _reader.offset + 1, _firstComment);
       _firstComment = null;
       _lastComment = null;
     }
     eofToken.setNext(eofToken);
     tail = tail.setNext(eofToken);
     if (_stackEnd >= 0) {
       _hasUnmatchedGroups2 = true;
     }
   }
+
   void appendKeywordToken(Keyword keyword) {
     if (_firstComment == null) {
       tail = tail.setNext(new KeywordToken(keyword, _tokenStart));
     } else {
       tail = tail.setNext(new KeywordTokenWithComment(keyword, _tokenStart, _firstComment));
       _firstComment = null;
       _lastComment = null;
     }
   }
+
   void appendStringToken(TokenType type, String value) {
     if (_firstComment == null) {
       tail = tail.setNext(new StringToken(type, value, _tokenStart));
     } else {
       tail = tail.setNext(new StringTokenWithComment(type, value, _tokenStart, _firstComment));
       _firstComment = null;
       _lastComment = null;
     }
   }
+
   void appendStringToken2(TokenType type, String value, int offset) {
     if (_firstComment == null) {
       tail = tail.setNext(new StringToken(type, value, _tokenStart + offset));
     } else {
       tail = tail.setNext(new StringTokenWithComment(type, value, _tokenStart + offset, _firstComment));
       _firstComment = null;
       _lastComment = null;
     }
   }
+
   void appendToken2(TokenType type) {
     if (_firstComment == null) {
       tail = tail.setNext(new Token(type, _tokenStart));
     } else {
       tail = tail.setNext(new TokenWithComment(type, _tokenStart, _firstComment));
       _firstComment = null;
       _lastComment = null;
     }
   }
+
   void appendToken3(TokenType type, int offset) {
     if (_firstComment == null) {
       tail = tail.setNext(new Token(type, offset));
     } else {
       tail = tail.setNext(new TokenWithComment(type, offset, _firstComment));
       _firstComment = null;
       _lastComment = null;
     }
   }
+
   void beginToken() {
     _tokenStart = _reader.offset;
   }
 
   /**
    * Return the beginning token corresponding to a closing brace that was found while scanning
    * inside a string interpolation expression. Tokens that cannot be matched with the closing brace
    * will be dropped from the stack.
    *
    * @return the token to be paired with the closing brace
@@ skipping 12 matching lines @@
 
   /**
    * Report an error at the current offset.
    *
    * @param errorCode the error code indicating the nature of the error
    * @param arguments any arguments needed to complete the error message
    */
   void reportError(ScannerErrorCode errorCode, List<Object> arguments) {
     _errorListener.onError(new AnalysisError.con2(source, _reader.offset, 1, errorCode, arguments));
   }
+
   int select(int choice, TokenType yesType, TokenType noType) {
     int next = _reader.advance();
     if (next == choice) {
       appendToken2(yesType);
       return _reader.advance();
     } else {
       appendToken2(noType);
       return next;
     }
   }
+
   int select2(int choice, TokenType yesType, TokenType noType, int offset) {
     int next = _reader.advance();
     if (next == choice) {
       appendToken3(yesType, offset);
       return _reader.advance();
     } else {
       appendToken3(noType, offset);
       return next;
     }
   }
+
   int tokenizeAmpersand(int next) {
     next = _reader.advance();
     if (next == 0x26) {
       appendToken2(TokenType.AMPERSAND_AMPERSAND);
       return _reader.advance();
     } else if (next == 0x3D) {
       appendToken2(TokenType.AMPERSAND_EQ);
       return _reader.advance();
     } else {
       appendToken2(TokenType.AMPERSAND);
       return next;
     }
   }
+
   int tokenizeBar(int next) {
     next = _reader.advance();
     if (next == 0x7C) {
       appendToken2(TokenType.BAR_BAR);
       return _reader.advance();
     } else if (next == 0x3D) {
       appendToken2(TokenType.BAR_EQ);
       return _reader.advance();
     } else {
       appendToken2(TokenType.BAR);
       return next;
     }
   }
+
   int tokenizeCaret(int next) => select(0x3D, TokenType.CARET_EQ, TokenType.CARET);
+
   int tokenizeDotOrNumber(int next) {
     int start = _reader.offset;
     next = _reader.advance();
     if (0x30 <= next && next <= 0x39) {
       return tokenizeFractionPart(next, start);
     } else if (0x2E == next) {
       return select(0x2E, TokenType.PERIOD_PERIOD_PERIOD, TokenType.PERIOD_PERIOD);
     } else {
       appendToken2(TokenType.PERIOD);
       return next;
     }
   }
+
   int tokenizeEquals(int next) {
     next = _reader.advance();
     if (next == 0x3D) {
       appendToken2(TokenType.EQ_EQ);
       return _reader.advance();
     } else if (next == 0x3E) {
       appendToken2(TokenType.FUNCTION);
       return _reader.advance();
     }
     appendToken2(TokenType.EQ);
     return next;
   }
+
   int tokenizeExclamation(int next) {
     next = _reader.advance();
     if (next == 0x3D) {
       appendToken2(TokenType.BANG_EQ);
       return _reader.advance();
     }
     appendToken2(TokenType.BANG);
     return next;
   }
+
   int tokenizeExponent(int next) {
     if (next == 0x2B || next == 0x2D) {
       next = _reader.advance();
     }
     bool hasDigits = false;
     while (true) {
       if (0x30 <= next && next <= 0x39) {
         hasDigits = true;
       } else {
         if (!hasDigits) {
           reportError(ScannerErrorCode.MISSING_DIGIT, []);
         }
         return next;
       }
       next = _reader.advance();
     }
   }
+
   int tokenizeFractionPart(int next, int start) {
     bool done = false;
     bool hasDigit = false;
     LOOP: while (!done) {
       if (0x30 <= next && next <= 0x39) {
         hasDigit = true;
       } else if (0x65 == next || 0x45 == next) {
         hasDigit = true;
         next = tokenizeExponent(_reader.advance());
         done = true;
         continue LOOP;
       } else {
         done = true;
         continue LOOP;
       }
       next = _reader.advance();
     }
     if (!hasDigit) {
       appendStringToken(TokenType.INT, _reader.getString(start, -2));
       if (0x2E == next) {
         return select2(0x2E, TokenType.PERIOD_PERIOD_PERIOD, TokenType.PERIOD_PERIOD, _reader.offset - 1);
       }
       appendToken3(TokenType.PERIOD, _reader.offset - 1);
       return bigSwitch(next);
     }
     appendStringToken(TokenType.DOUBLE, _reader.getString(start, next < 0 ? 0 : -1));
     return next;
   }
+
   int tokenizeGreaterThan(int next) {
     next = _reader.advance();
     if (0x3D == next) {
       appendToken2(TokenType.GT_EQ);
       return _reader.advance();
     } else if (0x3E == next) {
       next = _reader.advance();
       if (0x3D == next) {
         appendToken2(TokenType.GT_GT_EQ);
         return _reader.advance();
       } else {
         appendToken2(TokenType.GT_GT);
         return next;
       }
     } else {
       appendToken2(TokenType.GT);
       return next;
     }
   }
+
   int tokenizeHex(int next) {
     int start = _reader.offset - 1;
     bool hasDigits = false;
     while (true) {
       next = _reader.advance();
       if ((0x30 <= next && next <= 0x39) || (0x41 <= next && next <= 0x46) || (0x61 <= next && next <= 0x66)) {
         hasDigits = true;
       } else {
         if (!hasDigits) {
           reportError(ScannerErrorCode.MISSING_HEX_DIGIT, []);
         }
         appendStringToken(TokenType.HEXADECIMAL, _reader.getString(start, next < 0 ? 0 : -1));
         return next;
       }
     }
   }
+
   int tokenizeHexOrNumber(int next) {
     int x = _reader.peek();
     if (x == 0x78 || x == 0x58) {
       _reader.advance();
       return tokenizeHex(x);
     }
     return tokenizeNumber(next);
   }
+
   int tokenizeIdentifier(int next, int start, bool allowDollar) {
     while ((0x61 <= next && next <= 0x7A) || (0x41 <= next && next <= 0x5A) || (0x30 <= next && next <= 0x39) || next == 0x5F || (next == 0x24 && allowDollar)) {
       next = _reader.advance();
     }
     appendStringToken(TokenType.IDENTIFIER, _reader.getString(start, next < 0 ? 0 : -1));
     return next;
   }
+
   int tokenizeInterpolatedExpression(int next, int start) {
     appendBeginToken(TokenType.STRING_INTERPOLATION_EXPRESSION);
     next = _reader.advance();
     while (next != -1) {
       if (next == 0x7D) {
         BeginToken begin = findTokenMatchingClosingBraceInInterpolationExpression();
         if (begin == null) {
           beginToken();
           appendToken2(TokenType.CLOSE_CURLY_BRACKET);
           next = _reader.advance();
@@ skipping 15 matching lines @@
         next = bigSwitch(next);
       }
     }
     if (next == -1) {
       return next;
     }
     next = _reader.advance();
     beginToken();
     return next;
   }
+
   int tokenizeInterpolatedIdentifier(int next, int start) {
     appendStringToken2(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 0);
     if ((0x41 <= next && next <= 0x5A) || (0x61 <= next && next <= 0x7A) || next == 0x5F) {
       beginToken();
       next = tokenizeKeywordOrIdentifier(next, false);
     }
     beginToken();
     return next;
   }
+
   int tokenizeKeywordOrIdentifier(int next, bool allowDollar) {
     KeywordState state = KeywordState.KEYWORD_STATE;
     int start = _reader.offset;
     while (state != null && 0x61 <= next && next <= 0x7A) {
       state = state.next(next as int);
       next = _reader.advance();
     }
     if (state == null || state.keyword() == null) {
       return tokenizeIdentifier(next, start, allowDollar);
     }
     if ((0x41 <= next && next <= 0x5A) || (0x30 <= next && next <= 0x39) || next == 0x5F || next == 0x24) {
       return tokenizeIdentifier(next, start, allowDollar);
     } else if (next < 128) {
       appendKeywordToken(state.keyword());
       return next;
     } else {
       return tokenizeIdentifier(next, start, allowDollar);
     }
   }
+
   int tokenizeLessThan(int next) {
     next = _reader.advance();
     if (0x3D == next) {
       appendToken2(TokenType.LT_EQ);
       return _reader.advance();
     } else if (0x3C == next) {
       return select(0x3D, TokenType.LT_LT_EQ, TokenType.LT_LT);
     } else {
       appendToken2(TokenType.LT);
       return next;
     }
   }
+
   int tokenizeMinus(int next) {
     next = _reader.advance();
     if (next == 0x2D) {
       appendToken2(TokenType.MINUS_MINUS);
       return _reader.advance();
     } else if (next == 0x3D) {
       appendToken2(TokenType.MINUS_EQ);
       return _reader.advance();
     } else {
       appendToken2(TokenType.MINUS);
       return next;
     }
   }
+
   int tokenizeMultiLineComment(int next) {
     int nesting = 1;
     next = _reader.advance();
     while (true) {
       if (-1 == next) {
         reportError(ScannerErrorCode.UNTERMINATED_MULTI_LINE_COMMENT, []);
         appendCommentToken(TokenType.MULTI_LINE_COMMENT, _reader.getString(_tokenStart, 0));
         return next;
       } else if (0x2A == next) {
         next = _reader.advance();
@@ skipping 19 matching lines @@
         }
         recordStartOfLine();
       } else if (next == 0xA) {
         recordStartOfLine();
         next = _reader.advance();
       } else {
         next = _reader.advance();
       }
     }
   }
+
   int tokenizeMultiLineRawString(int quoteChar, int start) {
     int next = _reader.advance();
     outer: while (next != -1) {
       while (next != quoteChar) {
         next = _reader.advance();
         if (next == -1) {
           break outer;
         } else if (next == 0xD) {
           next = _reader.advance();
           if (next == 0xA) {
@@ skipping 11 matching lines @@
         if (next == quoteChar) {
           appendStringToken(TokenType.STRING, _reader.getString(start, 0));
           return _reader.advance();
         }
       }
     }
     reportError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, []);
     appendStringToken(TokenType.STRING, _reader.getString(start, 0));
     return _reader.advance();
   }
+
   int tokenizeMultiLineString(int quoteChar, int start, bool raw) {
     if (raw) {
       return tokenizeMultiLineRawString(quoteChar, start);
     }
     int next = _reader.advance();
     while (next != -1) {
       if (next == 0x24) {
         appendStringToken(TokenType.STRING, _reader.getString(start, -1));
         beginToken();
         next = tokenizeStringInterpolation(start);
@@ skipping 38 matching lines @@
         recordStartOfLine();
         next = _reader.advance();
       } else {
         next = _reader.advance();
       }
     }
     reportError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, []);
     appendStringToken(TokenType.STRING, _reader.getString(start, 0));
     return _reader.advance();
   }
+
   int tokenizeMultiply(int next) => select(0x3D, TokenType.STAR_EQ, TokenType.STAR);
+
   int tokenizeNumber(int next) {
     int start = _reader.offset;
     while (true) {
       next = _reader.advance();
       if (0x30 <= next && next <= 0x39) {
         continue;
       } else if (next == 0x2E) {
         return tokenizeFractionPart(_reader.advance(), start);
       } else if (next == 0x65 || next == 0x45) {
         return tokenizeFractionPart(next, start);
       } else {
         appendStringToken(TokenType.INT, _reader.getString(start, next < 0 ? 0 : -1));
         return next;
       }
     }
   }
+
   int tokenizeOpenSquareBracket(int next) {
     next = _reader.advance();
     if (next == 0x5D) {
       return select(0x3D, TokenType.INDEX_EQ, TokenType.INDEX);
     } else {
       appendBeginToken(TokenType.OPEN_SQUARE_BRACKET);
       return next;
     }
   }
+
   int tokenizePercent(int next) => select(0x3D, TokenType.PERCENT_EQ, TokenType.PERCENT);
+
   int tokenizePlus(int next) {
     next = _reader.advance();
     if (0x2B == next) {
       appendToken2(TokenType.PLUS_PLUS);
       return _reader.advance();
     } else if (0x3D == next) {
       appendToken2(TokenType.PLUS_EQ);
       return _reader.advance();
     } else {
       appendToken2(TokenType.PLUS);
       return next;
     }
   }
+
   int tokenizeSingleLineComment(int next) {
     while (true) {
       next = _reader.advance();
       if (-1 == next) {
         appendCommentToken(TokenType.SINGLE_LINE_COMMENT, _reader.getString(_tokenStart, 0));
         return next;
       } else if (0xA == next || 0xD == next) {
         appendCommentToken(TokenType.SINGLE_LINE_COMMENT, _reader.getString(_tokenStart, -1));
         return next;
       }
     }
   }
+
   int tokenizeSingleLineRawString(int next, int quoteChar, int start) {
     next = _reader.advance();
     while (next != -1) {
       if (next == quoteChar) {
         appendStringToken(TokenType.STRING, _reader.getString(start, 0));
         return _reader.advance();
       } else if (next == 0xD || next == 0xA) {
         reportError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, []);
         appendStringToken(TokenType.STRING, _reader.getString(start, 0));
         return _reader.advance();
       }
       next = _reader.advance();
     }
     reportError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, []);
     appendStringToken(TokenType.STRING, _reader.getString(start, 0));
     return _reader.advance();
   }
+
   int tokenizeSingleLineString(int next, int quoteChar, int start) {
     while (next != quoteChar) {
       if (next == 0x5C) {
         next = _reader.advance();
       } else if (next == 0x24) {
         appendStringToken(TokenType.STRING, _reader.getString(start, -1));
         beginToken();
         next = tokenizeStringInterpolation(start);
         start = _reader.offset;
         continue;
       }
       if (next <= 0xD && (next == 0xA || next == 0xD || next == -1)) {
         reportError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, []);
         appendStringToken(TokenType.STRING, _reader.getString(start, 0));
         return _reader.advance();
       }
       next = _reader.advance();
     }
     appendStringToken(TokenType.STRING, _reader.getString(start, 0));
     return _reader.advance();
   }
+
   int tokenizeSlashOrComment(int next) {
     next = _reader.advance();
     if (0x2A == next) {
       return tokenizeMultiLineComment(next);
     } else if (0x2F == next) {
       return tokenizeSingleLineComment(next);
     } else if (0x3D == next) {
       appendToken2(TokenType.SLASH_EQ);
       return _reader.advance();
     } else {
       appendToken2(TokenType.SLASH);
       return next;
     }
   }
+
   int tokenizeString(int next, int start, bool raw) {
     int quoteChar = next;
     next = _reader.advance();
     if (quoteChar == next) {
       next = _reader.advance();
       if (quoteChar == next) {
         return tokenizeMultiLineString(quoteChar, start, raw);
       } else {
         appendStringToken(TokenType.STRING, _reader.getString(start, -1));
         return next;
       }
     }
     if (raw) {
       return tokenizeSingleLineRawString(next, quoteChar, start);
     } else {
       return tokenizeSingleLineString(next, quoteChar, start);
     }
   }
+
   int tokenizeStringInterpolation(int start) {
     beginToken();
     int next = _reader.advance();
     if (next == 0x7B) {
       return tokenizeInterpolatedExpression(next, start);
     } else {
       return tokenizeInterpolatedIdentifier(next, start);
     }
   }
+
   int tokenizeTag(int next) {
     if (_reader.offset == 0) {
       if (_reader.peek() == 0x21) {
         do {
           next = _reader.advance();
         } while (next != 0xA && next != 0xD && next > 0);
         appendStringToken(TokenType.SCRIPT_TAG, _reader.getString(_tokenStart, 0));
         return next;
       }
     }
     appendToken2(TokenType.HASH);
     return _reader.advance();
   }
+
   int tokenizeTilde(int next) {
     next = _reader.advance();
     if (next == 0x2F) {
       return select(0x3D, TokenType.TILDE_SLASH_EQ, TokenType.TILDE_SLASH);
     } else {
       appendToken2(TokenType.TILDE);
       return next;
     }
   }
 }
+
 /**
  * Instances of the class `StringToken` represent a token whose value is independent of it's
  * type.
  *
  * @coverage dart.engine.parser
  */
 class StringToken extends Token {
-
   /**
    * The lexeme represented by this token.
    */
   String _value2;
 
   /**
    * 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
    */
   StringToken(TokenType type, String value, int offset) : super(type, offset) {
     this._value2 = StringUtilities.intern(value);
   }
+
   Token copy() => new StringToken(type, _value2, offset);
+
   String get lexeme => _value2;
+
   String value() => _value2;
 }
+
 /**
  * Instances of the class `TokenWithComment` represent a normal token that is preceded by
  * comments.
  *
  * @coverage dart.engine.parser
  */
 class TokenWithComment extends Token {
-
   /**
    * The first comment in the list of comments that precede this token.
    */
   Token _precedingComment;
 
   /**
    * Initialize a newly created token to have the given type and offset and to be preceded by the
    * comments reachable from the given comment.
    *
    * @param type the type of the token
    * @param offset the offset from the beginning of the file to the first character in the token
    * @param precedingComment the first comment in the list of comments that precede this token
    */
   TokenWithComment(TokenType type, int offset, Token precedingComment) : super(type, offset) {
     this._precedingComment = precedingComment;
   }
+
   Token copy() => new TokenWithComment(type, offset, _precedingComment);
+
   Token get precedingComments => _precedingComment;
 }
+
 /**
  * Instances of the class `Token` represent a token that was scanned from the input. Each
  * token knows which token follows it, acting as the head of a linked list of tokens.
  *
  * @coverage dart.engine.parser
  */
 class Token {
-
   /**
    * The type of the token.
    */
   TokenType type;
 
   /**
    * The offset from the beginning of the file to the first character in the token.
    */
   int offset = 0;
 
@@ skipping 98 matching lines @@
    * Set the next token in the token stream to the given token without changing which token is the
    * previous token for the given token.
    *
    * @param token the next token in the token stream
    * @return the token that was passed in
    */
   Token setNextWithoutSettingPrevious(Token token) {
     next = token;
     return token;
   }
+
   String toString() => lexeme;
 
   /**
    * Return the value of this token. For keyword tokens, this is the keyword associated with the
    * token, for other tokens it is the lexeme associated with the token.
    *
    * @return the value of this token
    */
   Object value() => type.lexeme;
 
@@ skipping 19 matching lines @@
     Token head = token.copy();
     Token tail = head;
     token = token.next;
     while (token != null) {
       tail = tail.setNext(token.copy());
       token = token.next;
     }
     return head;
   }
 }
+
 /**
  * The interface `CharacterReader`
  */
 abstract class CharacterReader {
-
   /**
    * Advance the current position and return the character at the new current position.
    *
    * @return the character at the new current position
    */
   int advance();
 
   /**
    * Return the current offset relative to the beginning of the source. Return the initial offset if
    * the scanner has not yet scanned the source code, and one (1) past the end of the source code if
@@ skipping 23 matching lines @@
   int peek();
 
   /**
    * Set the current offset relative to the beginning of the source. The new offset must be between
    * the initial offset and one (1) past the end of the source code.
    *
    * @param offset the new offset in the source
    */
   void set offset(int offset);
 }
+
 /**
  * Instances of the class `BeginTokenWithComment` represent a begin token that is preceded by
  * comments.
  *
  * @coverage dart.engine.parser
  */
 class BeginTokenWithComment extends BeginToken {
-
   /**
    * The first comment in the list of comments that precede this token.
    */
   Token _precedingComment;
 
   /**
    * Initialize a newly created token to have the given type and offset and to be preceded by the
    * comments reachable from the given comment.
    *
    * @param type the type of the token
    * @param offset the offset from the beginning of the file to the first character in the token
    * @param precedingComment the first comment in the list of comments that precede this token
    */
   BeginTokenWithComment(TokenType type, int offset, Token precedingComment) : super(type, offset) {
     this._precedingComment = precedingComment;
   }
+
   Token copy() => new BeginTokenWithComment(type, offset, copyComments(_precedingComment));
+
   Token get precedingComments => _precedingComment;
+
   void applyDelta(int delta) {
     super.applyDelta(delta);
     Token token = _precedingComment;
     while (token != null) {
       token.applyDelta(delta);
       token = token.next;
     }
   }
 }
+
 /**
  * Instances of the class `KeywordToken` represent a keyword in the language.
  *
  * @coverage dart.engine.parser
  */
 class KeywordToken extends Token {
-
   /**
    * The keyword being represented by this token.
    */
   Keyword keyword;
 
   /**
    * Initialize a newly created token to represent the given keyword.
    *
    * @param keyword the keyword being represented by this token
    * @param offset the offset from the beginning of the file to the first character in the token
    */
   KeywordToken(Keyword keyword, int offset) : super(TokenType.KEYWORD, offset) {
     this.keyword = keyword;
   }
+
   Token copy() => new KeywordToken(keyword, offset);
+
   String get lexeme => keyword.syntax;
+
   Keyword value() => keyword;
 }
+
 /**
  * Instances of the class `BeginToken` represent the opening half of a grouping pair of
  * tokens. This is used for curly brackets ('{'), parentheses ('('), and square brackets ('[').
  *
  * @coverage dart.engine.parser
  */
 class BeginToken extends Token {
-
   /**
    * The token that corresponds to this token.
    */
   Token endToken;
 
   /**
    * Initialize a newly created token representing the opening half of a grouping pair of tokens.
    *
    * @param type the type of the token
    * @param offset the offset from the beginning of the file to the first character in the token
    */
   BeginToken(TokenType type, int offset) : super(type, offset) {
     assert((identical(type, TokenType.OPEN_CURLY_BRACKET) || identical(type, TokenType.OPEN_PAREN) || identical(type, TokenType.OPEN_SQUARE_BRACKET) || identical(type, TokenType.STRING_INTERPOLATION_EXPRESSION)));
   }
+
   Token copy() => new BeginToken(type, offset);
 }
+
 /**
  * The enumeration `TokenClass` represents classes (or groups) of tokens with a similar use.
  *
  * @coverage dart.engine.parser
  */
 class TokenClass extends Enum<TokenClass> {
-
   /**
    * A value used to indicate that the token type is not part of any specific class of token.
    */
   static final TokenClass NO_CLASS = new TokenClass.con1('NO_CLASS', 0);
 
   /**
    * A value used to indicate that the token type is an additive operator.
    */
   static final TokenClass ADDITIVE_OPERATOR = new TokenClass.con2('ADDITIVE_OPERATOR', 1, 12);
 
@@ skipping 59 matching lines @@
 
   /**
    * 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);
 
   /**
    * A value used to indicate that the token type is a unary operator.
    */
   static final TokenClass UNARY_PREFIX_OPERATOR = new TokenClass.con2('UNARY_PREFIX_OPERATOR', 15, 14);
+
   static final List<TokenClass> values = [
       NO_CLASS,
       ADDITIVE_OPERATOR,
       ASSIGNMENT_OPERATOR,
       BITWISE_AND_OPERATOR,
       BITWISE_OR_OPERATOR,
       BITWISE_XOR_OPERATOR,
       CASCADE_OPERATOR,
       CONDITIONAL_OPERATOR,
       EQUALITY_OPERATOR,
       LOGICAL_AND_OPERATOR,
       LOGICAL_OR_OPERATOR,
       MULTIPLICATIVE_OPERATOR,
       RELATIONAL_OPERATOR,
       SHIFT_OPERATOR,
       UNARY_POSTFIX_OPERATOR,
       UNARY_PREFIX_OPERATOR];
 
   /**
    * The precedence of tokens of this class, or `0` if the such tokens do not represent an
    * operator.
    */
   int precedence = 0;
+
   TokenClass.con1(String name, int ordinal) : this.con2(name, ordinal, 0);
+
   TokenClass.con2(String name, int ordinal, int precedence) : super(name, ordinal) {
     this.precedence = precedence;
   }
 }
+
 /**
  * Instances of the class `KeywordTokenWithComment` implement a keyword token that is preceded
  * by comments.
  *
  * @coverage dart.engine.parser
  */
 class KeywordTokenWithComment extends KeywordToken {
-
   /**
    * The first comment in the list of comments that precede this token.
    */
   Token _precedingComment;
 
   /**
    * Initialize a newly created token to to represent the given keyword and to be preceded by the
    * comments reachable from the given comment.
    *
    * @param keyword the keyword being represented by this token
    * @param offset the offset from the beginning of the file to the first character in the token
    * @param precedingComment the first comment in the list of comments that precede this token
    */
   KeywordTokenWithComment(Keyword keyword, int offset, Token precedingComment) : super(keyword, offset) {
     this._precedingComment = precedingComment;
   }
+
   Token copy() => new KeywordTokenWithComment(keyword, offset, copyComments(_precedingComment));
+
   Token get precedingComments => _precedingComment;
+
   void applyDelta(int delta) {
     super.applyDelta(delta);
     Token token = _precedingComment;
     while (token != null) {
       token.applyDelta(delta);
       token = token.next;
     }
   }
 }
+
 /**
  * The enumeration `TokenType` defines the types of tokens that can be returned by the
  * scanner.
  *
  * @coverage dart.engine.parser
  */
 class TokenType extends Enum<TokenType> {
-
   /**
    * The type of the token that marks the end of the input.
    */
   static final TokenType EOF = new TokenType_EOF('EOF', 0, null, "");
+
   static final TokenType DOUBLE = new TokenType.con1('DOUBLE', 1);
+
   static final TokenType HEXADECIMAL = new TokenType.con1('HEXADECIMAL', 2);
+
   static final TokenType IDENTIFIER = new TokenType.con1('IDENTIFIER', 3);
+
   static final TokenType INT = new TokenType.con1('INT', 4);
+
   static final TokenType KEYWORD = new TokenType.con1('KEYWORD', 5);
+
   static final TokenType MULTI_LINE_COMMENT = new TokenType.con1('MULTI_LINE_COMMENT', 6);
+
   static final TokenType SCRIPT_TAG = new TokenType.con1('SCRIPT_TAG', 7);
+
   static final TokenType SINGLE_LINE_COMMENT = new TokenType.con1('SINGLE_LINE_COMMENT', 8);
+
   static final TokenType STRING = new TokenType.con1('STRING', 9);
+
   static final TokenType AMPERSAND = new TokenType.con2('AMPERSAND', 10, TokenClass.BITWISE_AND_OPERATOR, "&");
+
   static final TokenType AMPERSAND_AMPERSAND = new TokenType.con2('AMPERSAND_AMPERSAND', 11, TokenClass.LOGICAL_AND_OPERATOR, "&&");
+
   static final TokenType AMPERSAND_EQ = new TokenType.con2('AMPERSAND_EQ', 12, TokenClass.ASSIGNMENT_OPERATOR, "&=");
+
   static final TokenType AT = new TokenType.con2('AT', 13, null, "@");
+
   static final TokenType BANG = new TokenType.con2('BANG', 14, TokenClass.UNARY_PREFIX_OPERATOR, "!");
+
   static final TokenType BANG_EQ = new TokenType.con2('BANG_EQ', 15, TokenClass.EQUALITY_OPERATOR, "!=");
+
   static final TokenType BAR = new TokenType.con2('BAR', 16, TokenClass.BITWISE_OR_OPERATOR, "|");
+
   static final TokenType BAR_BAR = new TokenType.con2('BAR_BAR', 17, TokenClass.LOGICAL_OR_OPERATOR, "||");
+
   static final TokenType BAR_EQ = new TokenType.con2('BAR_EQ', 18, TokenClass.ASSIGNMENT_OPERATOR, "|=");
+
   static final TokenType COLON = new TokenType.con2('COLON', 19, null, ":");
+
   static final TokenType COMMA = new TokenType.con2('COMMA', 20, null, ",");
+
   static final TokenType CARET = new TokenType.con2('CARET', 21, TokenClass.BITWISE_XOR_OPERATOR, "^");
+
   static final TokenType CARET_EQ = new TokenType.con2('CARET_EQ', 22, TokenClass.ASSIGNMENT_OPERATOR, "^=");
+
   static final TokenType CLOSE_CURLY_BRACKET = new TokenType.con2('CLOSE_CURLY_BRACKET', 23, null, "}");
+
   static final TokenType CLOSE_PAREN = new TokenType.con2('CLOSE_PAREN', 24, null, ")");
+
   static final TokenType CLOSE_SQUARE_BRACKET = new TokenType.con2('CLOSE_SQUARE_BRACKET', 25, null, "]");
+
   static final TokenType EQ = new TokenType.con2('EQ', 26, TokenClass.ASSIGNMENT_OPERATOR, "=");
+
   static final TokenType EQ_EQ = new TokenType.con2('EQ_EQ', 27, TokenClass.EQUALITY_OPERATOR, "==");
+
   static final TokenType FUNCTION = new TokenType.con2('FUNCTION', 28, null, "=>");
+
   static final TokenType GT = new TokenType.con2('GT', 29, TokenClass.RELATIONAL_OPERATOR, ">");
+
   static final TokenType GT_EQ = new TokenType.con2('GT_EQ', 30, TokenClass.RELATIONAL_OPERATOR, ">=");
+
   static final TokenType GT_GT = new TokenType.con2('GT_GT', 31, TokenClass.SHIFT_OPERATOR, ">>");
+
   static final TokenType GT_GT_EQ = new TokenType.con2('GT_GT_EQ', 32, TokenClass.ASSIGNMENT_OPERATOR, ">>=");
+
   static final TokenType HASH = new TokenType.con2('HASH', 33, null, "#");
+
   static final TokenType INDEX = new TokenType.con2('INDEX', 34, TokenClass.UNARY_POSTFIX_OPERATOR, "[]");
+
   static final TokenType INDEX_EQ = new TokenType.con2('INDEX_EQ', 35, TokenClass.UNARY_POSTFIX_OPERATOR, "[]=");
+
   static final TokenType IS = new TokenType.con2('IS', 36, TokenClass.RELATIONAL_OPERATOR, "is");
+
   static final TokenType LT = new TokenType.con2('LT', 37, TokenClass.RELATIONAL_OPERATOR, "<");
+
   static final TokenType LT_EQ = new TokenType.con2('LT_EQ', 38, TokenClass.RELATIONAL_OPERATOR, "<=");
+
   static final TokenType LT_LT = new TokenType.con2('LT_LT', 39, TokenClass.SHIFT_OPERATOR, "<<");
+
   static final TokenType LT_LT_EQ = new TokenType.con2('LT_LT_EQ', 40, TokenClass.ASSIGNMENT_OPERATOR, "<<=");
+
   static final TokenType MINUS = new TokenType.con2('MINUS', 41, TokenClass.ADDITIVE_OPERATOR, "-");
+
   static final TokenType MINUS_EQ = new TokenType.con2('MINUS_EQ', 42, TokenClass.ASSIGNMENT_OPERATOR, "-=");
+
   static final TokenType MINUS_MINUS = new TokenType.con2('MINUS_MINUS', 43, TokenClass.UNARY_PREFIX_OPERATOR, "--");
+
   static final TokenType OPEN_CURLY_BRACKET = new TokenType.con2('OPEN_CURLY_BRACKET', 44, null, "{");
+
   static final TokenType OPEN_PAREN = new TokenType.con2('OPEN_PAREN', 45, TokenClass.UNARY_POSTFIX_OPERATOR, "(");
+
   static final TokenType OPEN_SQUARE_BRACKET = new TokenType.con2('OPEN_SQUARE_BRACKET', 46, TokenClass.UNARY_POSTFIX_OPERATOR, "[");
+
   static final TokenType PERCENT = new TokenType.con2('PERCENT', 47, TokenClass.MULTIPLICATIVE_OPERATOR, "%");
+
   static final TokenType PERCENT_EQ = new TokenType.con2('PERCENT_EQ', 48, TokenClass.ASSIGNMENT_OPERATOR, "%=");
+
   static final TokenType PERIOD = new TokenType.con2('PERIOD', 49, TokenClass.UNARY_POSTFIX_OPERATOR, ".");
+
   static final TokenType PERIOD_PERIOD = new TokenType.con2('PERIOD_PERIOD', 50, TokenClass.CASCADE_OPERATOR, "..");
+
   static final TokenType PLUS = new TokenType.con2('PLUS', 51, TokenClass.ADDITIVE_OPERATOR, "+");
+
   static final TokenType PLUS_EQ = new TokenType.con2('PLUS_EQ', 52, TokenClass.ASSIGNMENT_OPERATOR, "+=");
+
   static final TokenType PLUS_PLUS = new TokenType.con2('PLUS_PLUS', 53, TokenClass.UNARY_PREFIX_OPERATOR, "++");
+
   static final TokenType QUESTION = new TokenType.con2('QUESTION', 54, TokenClass.CONDITIONAL_OPERATOR, "?");
+
   static final TokenType SEMICOLON = new TokenType.con2('SEMICOLON', 55, null, ";");
+
   static final TokenType SLASH = new TokenType.con2('SLASH', 56, TokenClass.MULTIPLICATIVE_OPERATOR, "/");
+
   static final TokenType SLASH_EQ = new TokenType.con2('SLASH_EQ', 57, TokenClass.ASSIGNMENT_OPERATOR, "/=");
+
   static final TokenType STAR = new TokenType.con2('STAR', 58, TokenClass.MULTIPLICATIVE_OPERATOR, "*");
+
   static final TokenType STAR_EQ = new TokenType.con2('STAR_EQ', 59, TokenClass.ASSIGNMENT_OPERATOR, "*=");
+
   static final TokenType STRING_INTERPOLATION_EXPRESSION = new TokenType.con2('STRING_INTERPOLATION_EXPRESSION', 60, null, "\${");
+
   static final TokenType STRING_INTERPOLATION_IDENTIFIER = new TokenType.con2('STRING_INTERPOLATION_IDENTIFIER', 61, null, "\$");
+
   static final TokenType TILDE = new TokenType.con2('TILDE', 62, TokenClass.UNARY_PREFIX_OPERATOR, "~");
+
   static final TokenType TILDE_SLASH = new TokenType.con2('TILDE_SLASH', 63, TokenClass.MULTIPLICATIVE_OPERATOR, "~/");
+
   static final TokenType TILDE_SLASH_EQ = new TokenType.con2('TILDE_SLASH_EQ', 64, TokenClass.ASSIGNMENT_OPERATOR, "~/=");
+
   static final TokenType BACKPING = new TokenType.con2('BACKPING', 65, null, "`");
+
   static final TokenType BACKSLASH = new TokenType.con2('BACKSLASH', 66, null, "\\");
+
   static final TokenType PERIOD_PERIOD_PERIOD = new TokenType.con2('PERIOD_PERIOD_PERIOD', 67, null, "...");
+
   static final List<TokenType> values = [
       EOF,
       DOUBLE,
       HEXADECIMAL,
       IDENTIFIER,
       INT,
       KEYWORD,
       MULTI_LINE_COMMENT,
       SCRIPT_TAG,
       SINGLE_LINE_COMMENT,
@@ skipping 60 matching lines @@
   /**
    * The class of the token.
    */
   TokenClass _tokenClass;
 
   /**
    * The lexeme that defines this type of token, or `null` if there is more than one possible
    * lexeme for this type of token.
    */
   String lexeme;
+
   TokenType.con1(String name, int ordinal) : this.con2(name, ordinal, TokenClass.NO_CLASS, null);
+
   TokenType.con2(String name, int ordinal, TokenClass tokenClass, String lexeme) : super(name, ordinal) {
     this._tokenClass = tokenClass == null ? TokenClass.NO_CLASS : tokenClass;
     this.lexeme = lexeme;
   }
 
   /**
    * Return the precedence of the token, or `0` if the token does not represent an operator.
    *
    * @return the precedence of the token
    */
@@ skipping 83 matching lines @@
    */
   bool get isUnaryPrefixOperator => identical(_tokenClass, TokenClass.UNARY_PREFIX_OPERATOR);
 
   /**
    * Return `true` if this token type represents an operator that can be defined by users.
    *
    * @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-";
 }