Translate private Java members to private Dart members.

pkg/analyzer/lib/src/generated/scanner.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 // 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';
@@ skipping 10 matching lines @@
  */
 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();
+  static KeywordState KEYWORD_STATE = _createKeywordStateTable();
 
   /**
    * Create the next state in the state machine where we have already recognized the subset of
    * strings in the given array of strings starting at the given offset and having the given length.
    * All of these strings have a common prefix and the next character is at the given start index.
    *
    * @param start the index of the character in the strings used to transition to a new state
    * @param strings an array containing all of the strings that will be recognized by the state
    *          machine
    * @param offset the offset of the first string in the array that has the prefix that is assumed
    *          to have been recognized by the time we reach the state being built
    * @param length the number of strings in the array that pass through the state being built
    * @return the state that was created
    */
-  static KeywordState computeKeywordStateTable(int start, List<String> strings, int offset, int length) {
+  static KeywordState _computeKeywordStateTable(int start, List<String> strings, int offset, int length) {
     List<KeywordState> result = new List<KeywordState>(26);
     assert(length != 0);
     int chunk = 0x0;
     int chunkStart = -1;
     bool isLeaf = false;
     for (int i = offset; i < offset + length; i++) {
       if (strings[i].length == start) {
         isLeaf = true;
       }
       if (strings[i].length > start) {
         int c = strings[i].codeUnitAt(start);
         if (chunk != c) {
           if (chunkStart != -1) {
-            result[chunk - 0x61] = computeKeywordStateTable(start + 1, strings, chunkStart, i - chunkStart);
+            result[chunk - 0x61] = _computeKeywordStateTable(start + 1, strings, chunkStart, i - chunkStart);
           }
           chunkStart = i;
           chunk = c;
         }
       }
     }
     if (chunkStart != -1) {
       assert(result[chunk - 0x61] == null);
-      result[chunk - 0x61] = computeKeywordStateTable(start + 1, strings, chunkStart, offset + length - chunkStart);
+      result[chunk - 0x61] = _computeKeywordStateTable(start + 1, strings, chunkStart, offset + length - chunkStart);
     } else {
       assert(length == 1);
       return new KeywordState(_EMPTY_TABLE, strings[offset]);
     }
     if (isLeaf) {
       return new KeywordState(result, strings[offset]);
     } else {
       return new KeywordState(result, null);
     }
   }
 
   /**
    * Create the initial state in the state machine.
    *
    * @return the state that was created
    */
-  static KeywordState createKeywordStateTable() {
+  static KeywordState _createKeywordStateTable() {
     List<Keyword> values = Keyword.values;
     List<String> strings = new List<String>(values.length);
     for (int i = 0; i < values.length; i++) {
       strings[i] = values[i].syntax;
     }
     strings.sort();
-    return computeKeywordStateTable(0, strings, 0, strings.length);
+    return _computeKeywordStateTable(0, strings, 0, strings.length);
   }
 
   /**
    * A table mapping characters to the states to which those characters will transition. (The index
    * into the array is the offset from the character `'a'` to the transitioning character.)
    */
   List<KeywordState> _table;
 
   /**
    * The keyword that is recognized by this state, or `null` if this state is not a terminal
    * state.
    */
-  Keyword _keyword2;
+  Keyword _keyword;
 
   /**
    * Initialize a newly created state to have the given transitions and to recognize the keyword
    * with the given syntax.
    *
    * @param table a table mapping characters to the states to which those characters will transition
    * @param syntax the syntax of the keyword that is recognized by the state
    */
   KeywordState(List<KeywordState> table, String syntax) {
     this._table = table;
-    this._keyword2 = (syntax == null) ? null : Keyword.keywords[syntax];
+    this._keyword = (syntax == null) ? null : Keyword.keywords[syntax];
   }
 
   /**
    * Return the keyword that was recognized by this state, or `null` if this state does not
    * recognized a keyword.
    *
    * @return the keyword that was matched by reaching this state
    */
-  Keyword keyword() => _keyword2;
+  Keyword keyword() => _keyword;
 
   /**
    * 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];
 }
@@ skipping 277 matching lines @@
 
   /**
    * The lexeme for the keyword.
    */
   String _syntax;
 
   /**
    * A flag indicating whether the keyword is a pseudo-keyword. Pseudo keywords can be used as
    * identifiers.
    */
-  bool _isPseudoKeyword2 = false;
+  bool _isPseudoKeyword = false;
 
   /**
    * A table mapping the lexemes of keywords to the corresponding keyword.
    */
-  static Map<String, Keyword> keywords = createKeywordMap();
+  static Map<String, Keyword> keywords = _createKeywordMap();
 
   /**
    * Create a table mapping the lexemes of keywords to the corresponding keyword.
    *
    * @return the table that was created
    */
-  static Map<String, Keyword> createKeywordMap() {
+  static Map<String, Keyword> _createKeywordMap() {
     LinkedHashMap<String, Keyword> result = new LinkedHashMap<String, Keyword>();
     for (Keyword keyword in values) {
       result[keyword._syntax] = keyword;
     }
     return result;
   }
 
   /**
    * Initialize a newly created keyword to have the given syntax. The keyword is not a
    * pseudo-keyword.
    *
    * @param syntax the lexeme for the keyword
    */
   Keyword.con1(String name, int ordinal, String syntax) : this.con2(name, ordinal, syntax, false);
 
   /**
    * Initialize a newly created keyword to have the given syntax. The keyword is a pseudo-keyword if
    * 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._isPseudoKeyword2 = isPseudoKeyword;
+    this._isPseudoKeyword = isPseudoKeyword;
   }
 
   /**
    * Return the lexeme for the keyword.
    *
    * @return the lexeme for the keyword
    */
   String get syntax => _syntax;
 
   /**
    * Return `true` if this keyword is a pseudo-keyword. Pseudo keywords can be used as
    * identifiers.
    *
    * @return `true` if this keyword is a pseudo-keyword
    */
-  bool get isPseudoKeyword => _isPseudoKeyword2;
+  bool get 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.
    */
@@ skipping 84 matching lines @@
   /**
    * 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 _rightToken;
 
   /**
    * A flag indicating whether there were any tokens changed as a result of the modification.
    */
-  bool _hasNonWhitespaceChange2 = false;
+  bool _hasNonWhitespaceChange = 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;
@@ skipping 23 matching lines @@
    * @return a map from tokens that were copied to the copies of the tokens
    */
   TokenMap get tokenMap => _tokenMap;
 
   /**
    * Return `true` if there were any tokens either added or removed (or both) as a result of
    * the modification.
    *
    * @return `true` if there were any tokens changed as a result of the modification
    */
-  bool get hasNonWhitespaceChange => _hasNonWhitespaceChange2;
+  bool get hasNonWhitespaceChange => _hasNonWhitespaceChange;
 
   /**
    * 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) {
     //
     // Copy all of the tokens in the originalStream whose end is less than the replacement start.
     // (If the replacement start is equal to the end of an existing token, then it means that the
     // existing token might have been modified, so we need to rescan it.)
     //
     while (originalStream.type != TokenType.EOF && originalStream.end < index) {
-      originalStream = copyAndAdvance(originalStream, 0);
+      originalStream = _copyAndAdvance(originalStream, 0);
     }
     Token oldFirst = originalStream;
     Token oldLeftToken = originalStream.previous;
     _leftToken = tail;
     //
     // Skip tokens in the original stream until we find a token whose offset is greater than the end
     // of the removed region. (If the end of the removed region is equal to the beginning of an
     // existing token, then it means that the existing token might have been modified, so we need to
     // rescan it.)
     //
@@ skipping 32 matching lines @@
     //
     _reader.offset = scanStart - 1;
     int next = _reader.advance();
     while (next != -1 && _reader.offset <= scanEnd) {
       next = bigSwitch(next);
     }
     //
     // Copy the remaining tokens in the original stream, but apply the delta to the token's offset.
     //
     if (identical(originalStream.type, TokenType.EOF)) {
-      copyAndAdvance(originalStream, delta);
+      _copyAndAdvance(originalStream, delta);
       _rightToken = tail;
       _rightToken.setNextWithoutSettingPrevious(_rightToken);
     } else {
-      originalStream = copyAndAdvance(originalStream, delta);
+      originalStream = _copyAndAdvance(originalStream, delta);
       _rightToken = tail;
       while (originalStream.type != TokenType.EOF) {
-        originalStream = copyAndAdvance(originalStream, delta);
+        originalStream = _copyAndAdvance(originalStream, delta);
       }
-      Token eof = copyAndAdvance(originalStream, delta);
+      Token eof = _copyAndAdvance(originalStream, delta);
       eof.setNextWithoutSettingPrevious(eof);
     }
     //
     // If the index is immediately after an existing token and the inserted characters did not
     // change that original token, then adjust the leftToken to be the next token. For example, in
     // "a; c;" --> "a;b c;", the leftToken was ";", but this code advances it to "b" since "b" is
     // the first new token.
     //
     Token newFirst = _leftToken.next;
-    while (newFirst != _rightToken && oldFirst != oldRightToken && newFirst.type != TokenType.EOF && equalTokens(oldFirst, newFirst)) {
+    while (newFirst != _rightToken && oldFirst != oldRightToken && newFirst.type != TokenType.EOF && _equalTokens(oldFirst, newFirst)) {
       _tokenMap.put(oldFirst, newFirst);
       oldLeftToken = oldFirst;
       oldFirst = oldFirst.next;
       _leftToken = newFirst;
       newFirst = newFirst.next;
     }
     Token newLast = _rightToken.previous;
-    while (newLast != _leftToken && oldLast != oldLeftToken && newLast.type != TokenType.EOF && equalTokens(oldLast, newLast)) {
+    while (newLast != _leftToken && oldLast != oldLeftToken && newLast.type != TokenType.EOF && _equalTokens(oldLast, newLast)) {
       _tokenMap.put(oldLast, newLast);
       oldRightToken = oldLast;
       oldLast = oldLast.previous;
       _rightToken = newLast;
       newLast = newLast.previous;
     }
-    _hasNonWhitespaceChange2 = _leftToken.next != _rightToken || oldLeftToken.next != oldRightToken;
+    _hasNonWhitespaceChange = _leftToken.next != _rightToken || oldLeftToken.next != oldRightToken;
     //
     // TODO(brianwilkerson) Begin tokens are not getting associated with the corresponding end
     //     tokens (because the end tokens have not been copied when we're copying the begin tokens).
     //     This could have implications for parsing.
     // TODO(brianwilkerson) Update the lineInfo.
     //
     return firstToken;
   }
 
-  Token copyAndAdvance(Token originalToken, int delta) {
+  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 equalTokens(Token oldToken, Token newToken) => identical(oldToken.type, newToken.type) && oldToken.length == newToken.length && oldToken.lexeme == newToken.lexeme;
+  bool _equalTokens(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 56 matching lines @@
   List<BeginToken> _groupingStack = new List<BeginToken>();
 
   /**
    * The index of the last item in the [groupingStack], or `-1` if the stack is empty.
    */
   int _stackEnd = -1;
 
   /**
    * A flag indicating whether any unmatched groups were found during the parse.
    */
-  bool _hasUnmatchedGroups2 = false;
+  bool _hasUnmatchedGroups = 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
    */
   Scanner(this.source, CharacterReader reader, AnalysisErrorListener errorListener) {
     this._reader = reader;
@@ skipping 10 matching lines @@
    *
    * @return an array containing the offsets of the first character of each line in the source code
    */
   List<int> get lineStarts => _lineStarts;
 
   /**
    * Return `true` if any unmatched groups were found during the parse.
    *
    * @return `true` if any unmatched groups were found during the parse
    */
-  bool get hasUnmatchedGroups => _hasUnmatchedGroups2;
+  bool get hasUnmatchedGroups => _hasUnmatchedGroups;
 
   /**
    * Set whether documentation tokens should be scanned.
    *
    * @param preserveComments `true` if documentation tokens should be scanned
    */
   void set preserveComments(bool preserveComments) {
     this._preserveComments = preserveComments;
   }
 
@@ skipping 26 matching lines @@
    */
   Token tokenize() {
     InstrumentationBuilder instrumentation = Instrumentation.builder2("dart.engine.AbstractScanner.tokenize");
     int tokenCounter = 0;
     try {
       int next = _reader.advance();
       while (next != -1) {
         tokenCounter++;
         next = bigSwitch(next);
       }
-      appendEofToken();
+      _appendEofToken();
       instrumentation.metric2("tokensCount", tokenCounter);
       return firstToken;
     } finally {
       instrumentation.log2(2);
     }
   }
 
   /**
    * 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();
+    _beginToken();
     if (next == 0xD) {
       next = _reader.advance();
       if (next == 0xA) {
         next = _reader.advance();
       }
       recordStartOfLine();
       return next;
     } else if (next == 0xA) {
       next = _reader.advance();
       recordStartOfLine();
       return next;
     } else if (next == 0x9 || next == 0x20) {
       return _reader.advance();
     }
     if (next == 0x72) {
       int peek = _reader.peek();
       if (peek == 0x22 || peek == 0x27) {
         int start = _reader.offset;
-        return tokenizeString(_reader.advance(), start, true);
+        return _tokenizeString(_reader.advance(), start, true);
       }
     }
     if (0x61 <= next && next <= 0x7A) {
-      return tokenizeKeywordOrIdentifier(next, true);
+      return _tokenizeKeywordOrIdentifier(next, true);
     }
     if ((0x41 <= next && next <= 0x5A) || next == 0x5F || next == 0x24) {
-      return tokenizeIdentifier(next, _reader.offset, true);
+      return _tokenizeIdentifier(next, _reader.offset, true);
     }
     if (next == 0x3C) {
-      return tokenizeLessThan(next);
+      return _tokenizeLessThan(next);
     }
     if (next == 0x3E) {
-      return tokenizeGreaterThan(next);
+      return _tokenizeGreaterThan(next);
     }
     if (next == 0x3D) {
-      return tokenizeEquals(next);
+      return _tokenizeEquals(next);
     }
     if (next == 0x21) {
-      return tokenizeExclamation(next);
+      return _tokenizeExclamation(next);
     }
     if (next == 0x2B) {
-      return tokenizePlus(next);
+      return _tokenizePlus(next);
     }
     if (next == 0x2D) {
-      return tokenizeMinus(next);
+      return _tokenizeMinus(next);
     }
     if (next == 0x2A) {
-      return tokenizeMultiply(next);
+      return _tokenizeMultiply(next);
     }
     if (next == 0x25) {
-      return tokenizePercent(next);
+      return _tokenizePercent(next);
     }
     if (next == 0x26) {
-      return tokenizeAmpersand(next);
+      return _tokenizeAmpersand(next);
     }
     if (next == 0x7C) {
-      return tokenizeBar(next);
+      return _tokenizeBar(next);
     }
     if (next == 0x5E) {
-      return tokenizeCaret(next);
+      return _tokenizeCaret(next);
     }
     if (next == 0x5B) {
-      return tokenizeOpenSquareBracket(next);
+      return _tokenizeOpenSquareBracket(next);
     }
     if (next == 0x7E) {
-      return tokenizeTilde(next);
+      return _tokenizeTilde(next);
     }
     if (next == 0x5C) {
-      appendTokenOfType(TokenType.BACKSLASH);
+      _appendTokenOfType(TokenType.BACKSLASH);
       return _reader.advance();
     }
     if (next == 0x23) {
-      return tokenizeTag(next);
+      return _tokenizeTag(next);
     }
     if (next == 0x28) {
-      appendBeginToken(TokenType.OPEN_PAREN);
+      _appendBeginToken(TokenType.OPEN_PAREN);
       return _reader.advance();
     }
     if (next == 0x29) {
-      appendEndToken(TokenType.CLOSE_PAREN, TokenType.OPEN_PAREN);
+      _appendEndToken(TokenType.CLOSE_PAREN, TokenType.OPEN_PAREN);
       return _reader.advance();
     }
     if (next == 0x2C) {
-      appendTokenOfType(TokenType.COMMA);
+      _appendTokenOfType(TokenType.COMMA);
       return _reader.advance();
     }
     if (next == 0x3A) {
-      appendTokenOfType(TokenType.COLON);
+      _appendTokenOfType(TokenType.COLON);
       return _reader.advance();
     }
     if (next == 0x3B) {
-      appendTokenOfType(TokenType.SEMICOLON);
+      _appendTokenOfType(TokenType.SEMICOLON);
       return _reader.advance();
     }
     if (next == 0x3F) {
-      appendTokenOfType(TokenType.QUESTION);
+      _appendTokenOfType(TokenType.QUESTION);
       return _reader.advance();
     }
     if (next == 0x5D) {
-      appendEndToken(TokenType.CLOSE_SQUARE_BRACKET, TokenType.OPEN_SQUARE_BRACKET);
+      _appendEndToken(TokenType.CLOSE_SQUARE_BRACKET, TokenType.OPEN_SQUARE_BRACKET);
       return _reader.advance();
     }
     if (next == 0x60) {
-      appendTokenOfType(TokenType.BACKPING);
+      _appendTokenOfType(TokenType.BACKPING);
       return _reader.advance();
     }
     if (next == 0x7B) {
-      appendBeginToken(TokenType.OPEN_CURLY_BRACKET);
+      _appendBeginToken(TokenType.OPEN_CURLY_BRACKET);
       return _reader.advance();
     }
     if (next == 0x7D) {
-      appendEndToken(TokenType.CLOSE_CURLY_BRACKET, TokenType.OPEN_CURLY_BRACKET);
+      _appendEndToken(TokenType.CLOSE_CURLY_BRACKET, TokenType.OPEN_CURLY_BRACKET);
       return _reader.advance();
     }
     if (next == 0x2F) {
-      return tokenizeSlashOrComment(next);
+      return _tokenizeSlashOrComment(next);
     }
     if (next == 0x40) {
-      appendTokenOfType(TokenType.AT);
+      _appendTokenOfType(TokenType.AT);
       return _reader.advance();
     }
     if (next == 0x22 || next == 0x27) {
-      return tokenizeString(next, _reader.offset, false);
+      return _tokenizeString(next, _reader.offset, false);
     }
     if (next == 0x2E) {
-      return tokenizeDotOrNumber(next);
+      return _tokenizeDotOrNumber(next);
     }
     if (next == 0x30) {
-      return tokenizeHexOrNumber(next);
+      return _tokenizeHexOrNumber(next);
     }
     if (0x31 <= next && next <= 0x39) {
-      return tokenizeNumber(next);
+      return _tokenizeNumber(next);
     }
     if (next == -1) {
       return -1;
     }
-    reportError(ScannerErrorCode.ILLEGAL_CHARACTER, [next]);
+    _reportError(ScannerErrorCode.ILLEGAL_CHARACTER, [next]);
     return _reader.advance();
   }
 
   /**
    * Return the first token in the token stream that was scanned.
    *
    * @return the first token in the token stream that was scanned
    */
   Token get firstToken => _tokens.next;
 
   /**
    * Return the last token that was scanned.
    *
    * @return the last token that was scanned
    */
   Token get tail => _tail;
 
   /**
    * 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) {
+  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) {
+  void _appendCommentToken(TokenType type, String value) {
     // Ignore comment tokens if client specified that it doesn't need them.
     if (!_preserveComments) {
       return;
     }
     // OK, remember comment tokens.
     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) {
+  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() {
+  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;
     }
     // The EOF token points to itself so that there is always infinite look-ahead.
     eofToken.setNext(eofToken);
     _tail = _tail.setNext(eofToken);
     if (_stackEnd >= 0) {
-      _hasUnmatchedGroups2 = true;
+      _hasUnmatchedGroups = true;
     }
   }
 
-  void appendKeywordToken(Keyword keyword) {
+  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) {
+  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 appendStringTokenWithOffset(TokenType type, String value, int offset) {
+  void _appendStringTokenWithOffset(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 appendTokenOfType(TokenType type) {
+  void _appendTokenOfType(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 appendTokenOfTypeWithOffset(TokenType type, int offset) {
+  void _appendTokenOfTypeWithOffset(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() {
+  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
    */
-  BeginToken findTokenMatchingClosingBraceInInterpolationExpression() {
+  BeginToken _findTokenMatchingClosingBraceInInterpolationExpression() {
     while (_stackEnd >= 0) {
       BeginToken begin = _groupingStack[_stackEnd];
       if (identical(begin.type, TokenType.OPEN_CURLY_BRACKET) || identical(begin.type, TokenType.STRING_INTERPOLATION_EXPRESSION)) {
         return begin;
       }
-      _hasUnmatchedGroups2 = true;
+      _hasUnmatchedGroups = true;
       _groupingStack.removeAt(_stackEnd--);
     }
     //
     // We should never get to this point because we wouldn't be inside a string interpolation
     // expression unless we had previously found the start of the expression.
     //
     return null;
   }
 
   /**
    * 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) {
+  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 _select(int choice, TokenType yesType, TokenType noType) {
     int next = _reader.advance();
     if (next == choice) {
-      appendTokenOfType(yesType);
+      _appendTokenOfType(yesType);
       return _reader.advance();
     } else {
-      appendTokenOfType(noType);
+      _appendTokenOfType(noType);
       return next;
     }
   }
 
-  int selectWithOffset(int choice, TokenType yesType, TokenType noType, int offset) {
+  int _selectWithOffset(int choice, TokenType yesType, TokenType noType, int offset) {
     int next = _reader.advance();
     if (next == choice) {
-      appendTokenOfTypeWithOffset(yesType, offset);
+      _appendTokenOfTypeWithOffset(yesType, offset);
       return _reader.advance();
     } else {
-      appendTokenOfTypeWithOffset(noType, offset);
+      _appendTokenOfTypeWithOffset(noType, offset);
       return next;
     }
   }
 
-  int tokenizeAmpersand(int next) {
+  int _tokenizeAmpersand(int next) {
     // && &= &
     next = _reader.advance();
     if (next == 0x26) {
-      appendTokenOfType(TokenType.AMPERSAND_AMPERSAND);
+      _appendTokenOfType(TokenType.AMPERSAND_AMPERSAND);
       return _reader.advance();
     } else if (next == 0x3D) {
-      appendTokenOfType(TokenType.AMPERSAND_EQ);
+      _appendTokenOfType(TokenType.AMPERSAND_EQ);
       return _reader.advance();
     } else {
-      appendTokenOfType(TokenType.AMPERSAND);
+      _appendTokenOfType(TokenType.AMPERSAND);
       return next;
     }
   }
 
-  int tokenizeBar(int next) {
+  int _tokenizeBar(int next) {
     // | || |=
     next = _reader.advance();
     if (next == 0x7C) {
-      appendTokenOfType(TokenType.BAR_BAR);
+      _appendTokenOfType(TokenType.BAR_BAR);
       return _reader.advance();
     } else if (next == 0x3D) {
-      appendTokenOfType(TokenType.BAR_EQ);
+      _appendTokenOfType(TokenType.BAR_EQ);
       return _reader.advance();
     } else {
-      appendTokenOfType(TokenType.BAR);
+      _appendTokenOfType(TokenType.BAR);
       return next;
     }
   }
 
-  int tokenizeCaret(int next) => select(0x3D, TokenType.CARET_EQ, TokenType.CARET);
+  int _tokenizeCaret(int next) => _select(0x3D, TokenType.CARET_EQ, TokenType.CARET);
 
-  int tokenizeDotOrNumber(int next) {
+  int _tokenizeDotOrNumber(int next) {
     int start = _reader.offset;
     next = _reader.advance();
     if (0x30 <= next && next <= 0x39) {
-      return tokenizeFractionPart(next, start);
+      return _tokenizeFractionPart(next, start);
     } else if (0x2E == next) {
-      return select(0x2E, TokenType.PERIOD_PERIOD_PERIOD, TokenType.PERIOD_PERIOD);
+      return _select(0x2E, TokenType.PERIOD_PERIOD_PERIOD, TokenType.PERIOD_PERIOD);
     } else {
-      appendTokenOfType(TokenType.PERIOD);
+      _appendTokenOfType(TokenType.PERIOD);
       return next;
     }
   }
 
-  int tokenizeEquals(int next) {
+  int _tokenizeEquals(int next) {
     // = == =>
     next = _reader.advance();
     if (next == 0x3D) {
-      appendTokenOfType(TokenType.EQ_EQ);
+      _appendTokenOfType(TokenType.EQ_EQ);
       return _reader.advance();
     } else if (next == 0x3E) {
-      appendTokenOfType(TokenType.FUNCTION);
+      _appendTokenOfType(TokenType.FUNCTION);
       return _reader.advance();
     }
-    appendTokenOfType(TokenType.EQ);
+    _appendTokenOfType(TokenType.EQ);
     return next;
   }
 
-  int tokenizeExclamation(int next) {
+  int _tokenizeExclamation(int next) {
     // ! !=
     next = _reader.advance();
     if (next == 0x3D) {
-      appendTokenOfType(TokenType.BANG_EQ);
+      _appendTokenOfType(TokenType.BANG_EQ);
       return _reader.advance();
     }
-    appendTokenOfType(TokenType.BANG);
+    _appendTokenOfType(TokenType.BANG);
     return next;
   }
 
-  int tokenizeExponent(int 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, []);
+          _reportError(ScannerErrorCode.MISSING_DIGIT, []);
         }
         return next;
       }
       next = _reader.advance();
     }
   }
 
-  int tokenizeFractionPart(int next, int start) {
+  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());
+        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));
+      _appendStringToken(TokenType.INT, _reader.getString(start, -2));
       if (0x2E == next) {
-        return selectWithOffset(0x2E, TokenType.PERIOD_PERIOD_PERIOD, TokenType.PERIOD_PERIOD, _reader.offset - 1);
+        return _selectWithOffset(0x2E, TokenType.PERIOD_PERIOD_PERIOD, TokenType.PERIOD_PERIOD, _reader.offset - 1);
       }
-      appendTokenOfTypeWithOffset(TokenType.PERIOD, _reader.offset - 1);
+      _appendTokenOfTypeWithOffset(TokenType.PERIOD, _reader.offset - 1);
       return bigSwitch(next);
     }
-    appendStringToken(TokenType.DOUBLE, _reader.getString(start, next < 0 ? 0 : -1));
+    _appendStringToken(TokenType.DOUBLE, _reader.getString(start, next < 0 ? 0 : -1));
     return next;
   }
 
-  int tokenizeGreaterThan(int next) {
+  int _tokenizeGreaterThan(int next) {
     // > >= >> >>=
     next = _reader.advance();
     if (0x3D == next) {
-      appendTokenOfType(TokenType.GT_EQ);
+      _appendTokenOfType(TokenType.GT_EQ);
       return _reader.advance();
     } else if (0x3E == next) {
       next = _reader.advance();
       if (0x3D == next) {
-        appendTokenOfType(TokenType.GT_GT_EQ);
+        _appendTokenOfType(TokenType.GT_GT_EQ);
         return _reader.advance();
       } else {
-        appendTokenOfType(TokenType.GT_GT);
+        _appendTokenOfType(TokenType.GT_GT);
         return next;
       }
     } else {
-      appendTokenOfType(TokenType.GT);
+      _appendTokenOfType(TokenType.GT);
       return next;
     }
   }
 
-  int tokenizeHex(int 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, []);
+          _reportError(ScannerErrorCode.MISSING_HEX_DIGIT, []);
         }
-        appendStringToken(TokenType.HEXADECIMAL, _reader.getString(start, next < 0 ? 0 : -1));
+        _appendStringToken(TokenType.HEXADECIMAL, _reader.getString(start, next < 0 ? 0 : -1));
         return next;
       }
     }
   }
 
-  int tokenizeHexOrNumber(int next) {
+  int _tokenizeHexOrNumber(int next) {
     int x = _reader.peek();
     if (x == 0x78 || x == 0x58) {
       _reader.advance();
-      return tokenizeHex(x);
+      return _tokenizeHex(x);
     }
-    return tokenizeNumber(next);
+    return _tokenizeNumber(next);
   }
 
-  int tokenizeIdentifier(int next, int start, bool allowDollar) {
+  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));
+    _appendStringToken(TokenType.IDENTIFIER, _reader.getString(start, next < 0 ? 0 : -1));
     return next;
   }
 
-  int tokenizeInterpolatedExpression(int next, int start) {
-    appendBeginToken(TokenType.STRING_INTERPOLATION_EXPRESSION);
+  int _tokenizeInterpolatedExpression(int next, int start) {
+    _appendBeginToken(TokenType.STRING_INTERPOLATION_EXPRESSION);
     next = _reader.advance();
     while (next != -1) {
       if (next == 0x7D) {
-        BeginToken begin = findTokenMatchingClosingBraceInInterpolationExpression();
+        BeginToken begin = _findTokenMatchingClosingBraceInInterpolationExpression();
         if (begin == null) {
-          beginToken();
-          appendTokenOfType(TokenType.CLOSE_CURLY_BRACKET);
+          _beginToken();
+          _appendTokenOfType(TokenType.CLOSE_CURLY_BRACKET);
           next = _reader.advance();
-          beginToken();
+          _beginToken();
           return next;
         } else if (identical(begin.type, TokenType.OPEN_CURLY_BRACKET)) {
-          beginToken();
-          appendEndToken(TokenType.CLOSE_CURLY_BRACKET, TokenType.OPEN_CURLY_BRACKET);
+          _beginToken();
+          _appendEndToken(TokenType.CLOSE_CURLY_BRACKET, TokenType.OPEN_CURLY_BRACKET);
           next = _reader.advance();
-          beginToken();
+          _beginToken();
         } else if (identical(begin.type, TokenType.STRING_INTERPOLATION_EXPRESSION)) {
-          beginToken();
-          appendEndToken(TokenType.CLOSE_CURLY_BRACKET, TokenType.STRING_INTERPOLATION_EXPRESSION);
+          _beginToken();
+          _appendEndToken(TokenType.CLOSE_CURLY_BRACKET, TokenType.STRING_INTERPOLATION_EXPRESSION);
           next = _reader.advance();
-          beginToken();
+          _beginToken();
           return next;
         }
       } else {
         next = bigSwitch(next);
       }
     }
     if (next == -1) {
       return next;
     }
     next = _reader.advance();
-    beginToken();
+    _beginToken();
     return next;
   }
 
-  int tokenizeInterpolatedIdentifier(int next, int start) {
-    appendStringTokenWithOffset(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 0);
+  int _tokenizeInterpolatedIdentifier(int next, int start) {
+    _appendStringTokenWithOffset(TokenType.STRING_INTERPOLATION_IDENTIFIER, "\$", 0);
     if ((0x41 <= next && next <= 0x5A) || (0x61 <= next && next <= 0x7A) || next == 0x5F) {
-      beginToken();
-      next = tokenizeKeywordOrIdentifier(next, false);
+      _beginToken();
+      next = _tokenizeKeywordOrIdentifier(next, false);
     }
-    beginToken();
+    _beginToken();
     return next;
   }
 
-  int tokenizeKeywordOrIdentifier(int next, bool allowDollar) {
+  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);
       next = _reader.advance();
     }
     if (state == null || state.keyword() == null) {
-      return tokenizeIdentifier(next, start, allowDollar);
+      return _tokenizeIdentifier(next, start, allowDollar);
     }
     if ((0x41 <= next && next <= 0x5A) || (0x30 <= next && next <= 0x39) || next == 0x5F || next == 0x24) {
-      return tokenizeIdentifier(next, start, allowDollar);
+      return _tokenizeIdentifier(next, start, allowDollar);
     } else if (next < 128) {
-      appendKeywordToken(state.keyword());
+      _appendKeywordToken(state.keyword());
       return next;
     } else {
-      return tokenizeIdentifier(next, start, allowDollar);
+      return _tokenizeIdentifier(next, start, allowDollar);
     }
   }
 
-  int tokenizeLessThan(int next) {
+  int _tokenizeLessThan(int next) {
     // < <= << <<=
     next = _reader.advance();
     if (0x3D == next) {
-      appendTokenOfType(TokenType.LT_EQ);
+      _appendTokenOfType(TokenType.LT_EQ);
       return _reader.advance();
     } else if (0x3C == next) {
-      return select(0x3D, TokenType.LT_LT_EQ, TokenType.LT_LT);
+      return _select(0x3D, TokenType.LT_LT_EQ, TokenType.LT_LT);
     } else {
-      appendTokenOfType(TokenType.LT);
+      _appendTokenOfType(TokenType.LT);
       return next;
     }
   }
 
-  int tokenizeMinus(int next) {
+  int _tokenizeMinus(int next) {
     // - -- -=
     next = _reader.advance();
     if (next == 0x2D) {
-      appendTokenOfType(TokenType.MINUS_MINUS);
+      _appendTokenOfType(TokenType.MINUS_MINUS);
       return _reader.advance();
     } else if (next == 0x3D) {
-      appendTokenOfType(TokenType.MINUS_EQ);
+      _appendTokenOfType(TokenType.MINUS_EQ);
       return _reader.advance();
     } else {
-      appendTokenOfType(TokenType.MINUS);
+      _appendTokenOfType(TokenType.MINUS);
       return next;
     }
   }
 
-  int tokenizeMultiLineComment(int 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));
+        _reportError(ScannerErrorCode.UNTERMINATED_MULTI_LINE_COMMENT, []);
+        _appendCommentToken(TokenType.MULTI_LINE_COMMENT, _reader.getString(_tokenStart, 0));
         return next;
       } else if (0x2A == next) {
         next = _reader.advance();
         if (0x2F == next) {
           --nesting;
           if (0 == nesting) {
-            appendCommentToken(TokenType.MULTI_LINE_COMMENT, _reader.getString(_tokenStart, 0));
+            _appendCommentToken(TokenType.MULTI_LINE_COMMENT, _reader.getString(_tokenStart, 0));
             return _reader.advance();
           } else {
             next = _reader.advance();
           }
         }
       } else if (0x2F == next) {
         next = _reader.advance();
         if (0x2A == next) {
           next = _reader.advance();
           ++nesting;
         }
       } else if (next == 0xD) {
         next = _reader.advance();
         if (next == 0xA) {
           next = _reader.advance();
         }
         recordStartOfLine();
       } else if (next == 0xA) {
         recordStartOfLine();
         next = _reader.advance();
       } else {
         next = _reader.advance();
       }
     }
   }
 
-  int tokenizeMultiLineRawString(int quoteChar, int start) {
+  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) {
             next = _reader.advance();
           }
           recordStartOfLine();
         } else if (next == 0xA) {
           recordStartOfLine();
           next = _reader.advance();
         }
       }
       next = _reader.advance();
       if (next == quoteChar) {
         next = _reader.advance();
         if (next == quoteChar) {
-          appendStringToken(TokenType.STRING, _reader.getString(start, 0));
+          _appendStringToken(TokenType.STRING, _reader.getString(start, 0));
           return _reader.advance();
         }
       }
     }
-    reportError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, []);
-    appendStringToken(TokenType.STRING, _reader.getString(start, 0));
+    _reportError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, []);
+    _appendStringToken(TokenType.STRING, _reader.getString(start, 0));
     return _reader.advance();
   }
 
-  int tokenizeMultiLineString(int quoteChar, int start, bool raw) {
+  int _tokenizeMultiLineString(int quoteChar, int start, bool raw) {
     if (raw) {
-      return tokenizeMultiLineRawString(quoteChar, start);
+      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);
+        _appendStringToken(TokenType.STRING, _reader.getString(start, -1));
+        _beginToken();
+        next = _tokenizeStringInterpolation(start);
         start = _reader.offset;
         continue;
       }
       if (next == quoteChar) {
         next = _reader.advance();
         if (next == quoteChar) {
           next = _reader.advance();
           if (next == quoteChar) {
-            appendStringToken(TokenType.STRING, _reader.getString(start, 0));
+            _appendStringToken(TokenType.STRING, _reader.getString(start, 0));
             return _reader.advance();
           }
         }
         continue;
       }
       if (next == 0x5C) {
         next = _reader.advance();
         if (next == -1) {
           break;
         }
@@ skipping 15 matching lines @@
           next = _reader.advance();
         }
         recordStartOfLine();
       } else if (next == 0xA) {
         recordStartOfLine();
         next = _reader.advance();
       } else {
         next = _reader.advance();
       }
     }
-    reportError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, []);
-    appendStringToken(TokenType.STRING, _reader.getString(start, 0));
+    _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 _tokenizeMultiply(int next) => _select(0x3D, TokenType.STAR_EQ, TokenType.STAR);
 
-  int tokenizeNumber(int next) {
+  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);
+        return _tokenizeFractionPart(_reader.advance(), start);
       } else if (next == 0x65 || next == 0x45) {
-        return tokenizeFractionPart(next, start);
+        return _tokenizeFractionPart(next, start);
       } else {
-        appendStringToken(TokenType.INT, _reader.getString(start, next < 0 ? 0 : -1));
+        _appendStringToken(TokenType.INT, _reader.getString(start, next < 0 ? 0 : -1));
         return next;
       }
     }
   }
 
-  int tokenizeOpenSquareBracket(int next) {
+  int _tokenizeOpenSquareBracket(int next) {
     // [ []  []=
     next = _reader.advance();
     if (next == 0x5D) {
-      return select(0x3D, TokenType.INDEX_EQ, TokenType.INDEX);
+      return _select(0x3D, TokenType.INDEX_EQ, TokenType.INDEX);
     } else {
-      appendBeginToken(TokenType.OPEN_SQUARE_BRACKET);
+      _appendBeginToken(TokenType.OPEN_SQUARE_BRACKET);
       return next;
     }
   }
 
-  int tokenizePercent(int next) => select(0x3D, TokenType.PERCENT_EQ, TokenType.PERCENT);
+  int _tokenizePercent(int next) => _select(0x3D, TokenType.PERCENT_EQ, TokenType.PERCENT);
 
-  int tokenizePlus(int next) {
+  int _tokenizePlus(int next) {
     // + ++ +=
     next = _reader.advance();
     if (0x2B == next) {
-      appendTokenOfType(TokenType.PLUS_PLUS);
+      _appendTokenOfType(TokenType.PLUS_PLUS);
       return _reader.advance();
     } else if (0x3D == next) {
-      appendTokenOfType(TokenType.PLUS_EQ);
+      _appendTokenOfType(TokenType.PLUS_EQ);
       return _reader.advance();
     } else {
-      appendTokenOfType(TokenType.PLUS);
+      _appendTokenOfType(TokenType.PLUS);
       return next;
     }
   }
 
-  int tokenizeSingleLineComment(int next) {
+  int _tokenizeSingleLineComment(int next) {
     while (true) {
       next = _reader.advance();
       if (-1 == next) {
-        appendCommentToken(TokenType.SINGLE_LINE_COMMENT, _reader.getString(_tokenStart, 0));
+        _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));
+        _appendCommentToken(TokenType.SINGLE_LINE_COMMENT, _reader.getString(_tokenStart, -1));
         return next;
       }
     }
   }
 
-  int tokenizeSingleLineRawString(int next, int quoteChar, int start) {
+  int _tokenizeSingleLineRawString(int next, int quoteChar, int start) {
     next = _reader.advance();
     while (next != -1) {
       if (next == quoteChar) {
-        appendStringToken(TokenType.STRING, _reader.getString(start, 0));
+        _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));
+        _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));
+    _reportError(ScannerErrorCode.UNTERMINATED_STRING_LITERAL, []);
+    _appendStringToken(TokenType.STRING, _reader.getString(start, 0));
     return _reader.advance();
   }
 
-  int tokenizeSingleLineString(int next, int quoteChar, int start) {
+  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);
+        _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));
+        _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));
+    _appendStringToken(TokenType.STRING, _reader.getString(start, 0));
     return _reader.advance();
   }
 
-  int tokenizeSlashOrComment(int next) {
+  int _tokenizeSlashOrComment(int next) {
     next = _reader.advance();
     if (0x2A == next) {
-      return tokenizeMultiLineComment(next);
+      return _tokenizeMultiLineComment(next);
     } else if (0x2F == next) {
-      return tokenizeSingleLineComment(next);
+      return _tokenizeSingleLineComment(next);
     } else if (0x3D == next) {
-      appendTokenOfType(TokenType.SLASH_EQ);
+      _appendTokenOfType(TokenType.SLASH_EQ);
       return _reader.advance();
     } else {
-      appendTokenOfType(TokenType.SLASH);
+      _appendTokenOfType(TokenType.SLASH);
       return next;
     }
   }
 
-  int tokenizeString(int next, int start, bool raw) {
+  int _tokenizeString(int next, int start, bool raw) {
     int quoteChar = next;
     next = _reader.advance();
     if (quoteChar == next) {
       next = _reader.advance();
       if (quoteChar == next) {
         // Multiline string.
-        return tokenizeMultiLineString(quoteChar, start, raw);
+        return _tokenizeMultiLineString(quoteChar, start, raw);
       } else {
         // Empty string.
-        appendStringToken(TokenType.STRING, _reader.getString(start, -1));
+        _appendStringToken(TokenType.STRING, _reader.getString(start, -1));
         return next;
       }
     }
     if (raw) {
-      return tokenizeSingleLineRawString(next, quoteChar, start);
+      return _tokenizeSingleLineRawString(next, quoteChar, start);
     } else {
-      return tokenizeSingleLineString(next, quoteChar, start);
+      return _tokenizeSingleLineString(next, quoteChar, start);
     }
   }
 
-  int tokenizeStringInterpolation(int start) {
-    beginToken();
+  int _tokenizeStringInterpolation(int start) {
+    _beginToken();
     int next = _reader.advance();
     if (next == 0x7B) {
-      return tokenizeInterpolatedExpression(next, start);
+      return _tokenizeInterpolatedExpression(next, start);
     } else {
-      return tokenizeInterpolatedIdentifier(next, start);
+      return _tokenizeInterpolatedIdentifier(next, start);
     }
   }
 
-  int tokenizeTag(int next) {
+  int _tokenizeTag(int next) {
     // # or #!.*[\n\r]
     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));
+        _appendStringToken(TokenType.SCRIPT_TAG, _reader.getString(_tokenStart, 0));
         return next;
       }
     }
-    appendTokenOfType(TokenType.HASH);
+    _appendTokenOfType(TokenType.HASH);
     return _reader.advance();
   }
 
-  int tokenizeTilde(int next) {
+  int _tokenizeTilde(int next) {
     // ~ ~/ ~/=
     next = _reader.advance();
     if (next == 0x2F) {
-      return select(0x3D, TokenType.TILDE_SLASH_EQ, TokenType.TILDE_SLASH);
+      return _select(0x3D, TokenType.TILDE_SLASH_EQ, TokenType.TILDE_SLASH);
     } else {
-      appendTokenOfType(TokenType.TILDE);
+      _appendTokenOfType(TokenType.TILDE);
       return next;
     }
   }
 }
 
 /**
  * Instances of the class `StringToken` represent a token whose value is independent of it's
  * type.
  */
 class StringToken extends Token {
   /**
    * The lexeme represented by this token.
    */
-  String _value2;
+  String _value;
 
   /**
    * 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);
+    this._value = StringUtilities.intern(value);
   }
 
-  Token copy() => new StringToken(type, _value2, offset);
+  Token copy() => new StringToken(type, _value, offset);
 
-  String get lexeme => _value2;
+  String get lexeme => _value;
 
-  String value() => _value2;
+  String value() => _value;
 }
 
 /**
  * Instances of the class `TokenWithComment` represent a normal token that is preceded by
  * comments.
  */
 class TokenWithComment extends Token {
   /**
    * The first comment in the list of comments that precede this token.
    */
@@ skipping 114 matching lines @@
   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
    */
   bool get isUserDefinableOperator => type.isUserDefinableOperator;
 
   /**
+   * Return `true` if this token has any one of the given types.
+   *
+   * @param types the types of token that are being tested for
+   * @return `true` if this token has any of the given types
+   */
+  bool matchesAny(List<TokenType> types) {
+    for (TokenType type in types) {
+      if (identical(this.type, type)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  /**
    * Set the next token in the token stream to the given token. This has the side-effect of setting
    * this token to be the previous token for the given token.
    *
    * @param token the next token in the token stream
    * @return the token that was passed in
    */
   Token setNext(Token token) {
     _next = token;
     token.previous = this;
     return token;
@@ skipping 678 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-";
 }