merge PrecedenceInfo into TokenType and update all refs

pkg/front_end/lib/src/fasta/scanner/abstract_scanner.dart

 // Copyright (c) 2012, 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.
 
 library fasta.scanner.abstract_scanner;
 
 import 'dart:collection' show ListMixin;
 
 import 'dart:typed_data' show Uint16List, Uint32List;
 
 import '../../scanner/token.dart' show TokenType;
 
 import '../scanner.dart'
     show ErrorToken, Keyword, Scanner, buildUnexpectedCharacterToken;
 
 import 'error_token.dart' show UnterminatedToken;
 
 import 'keyword_state.dart' show KeywordState;
 
-import 'precedence.dart';
-
 import 'token.dart'
     show BeginGroupToken, CommentToken, DartDocToken, SymbolToken, Token;
 
 import 'token_constants.dart';
 
 import 'characters.dart';
 
 abstract class AbstractScanner implements Scanner {
   final bool includeComments;
 
@@ skipping 234 matching lines @@
     int nextLower = next | 0x20;
 
     if ($a <= nextLower && nextLower <= $z) {
       if (identical($r, next)) {
         return tokenizeRawStringKeywordOrIdentifier(next);
       }
       return tokenizeKeywordOrIdentifier(next, true);
     }
 
     if (identical(next, $CLOSE_PAREN)) {
-      return appendEndGroup(CLOSE_PAREN_INFO, OPEN_PAREN_TOKEN);
+      return appendEndGroup(TokenType.CLOSE_PAREN, OPEN_PAREN_TOKEN);
     }
 
     if (identical(next, $OPEN_PAREN)) {
-      appendBeginGroup(OPEN_PAREN_INFO);
+      appendBeginGroup(TokenType.OPEN_PAREN);
       return advance();
     }
 
     if (identical(next, $SEMICOLON)) {
-      appendPrecedenceToken(SEMICOLON_INFO);
+      appendPrecedenceToken(TokenType.SEMICOLON);
       // Type parameters and arguments cannot contain semicolon.
       discardOpenLt();
       return advance();
     }
 
     if (identical(next, $PERIOD)) {
       return tokenizeDotsOrNumber(next);
     }
 
     if (identical(next, $COMMA)) {
-      appendPrecedenceToken(COMMA_INFO);
+      appendPrecedenceToken(TokenType.COMMA);
       return advance();
     }
 
     if (identical(next, $EQ)) {
       return tokenizeEquals(next);
     }
 
     if (identical(next, $CLOSE_CURLY_BRACKET)) {
-      return appendEndGroup(CLOSE_CURLY_BRACKET_INFO, OPEN_CURLY_BRACKET_TOKEN);
+      return appendEndGroup(
+          TokenType.CLOSE_CURLY_BRACKET, OPEN_CURLY_BRACKET_TOKEN);
     }
 
     if (identical(next, $SLASH)) {
       return tokenizeSlashOrComment(next);
     }
 
     if (identical(next, $OPEN_CURLY_BRACKET)) {
-      appendBeginGroup(OPEN_CURLY_BRACKET_INFO);
+      appendBeginGroup(TokenType.OPEN_CURLY_BRACKET);
       return advance();
     }
 
     if (identical(next, $DQ) || identical(next, $SQ)) {
       return tokenizeString(next, scanOffset, false);
     }
 
     if (identical(next, $_)) {
       return tokenizeKeywordOrIdentifier(next, true);
     }
 
     if (identical(next, $COLON)) {
-      appendPrecedenceToken(COLON_INFO);
+      appendPrecedenceToken(TokenType.COLON);
       return advance();
     }
 
     if (identical(next, $LT)) {
       return tokenizeLessThan(next);
     }
 
     if (identical(next, $GT)) {
       return tokenizeGreaterThan(next);
     }
 
     if (identical(next, $BANG)) {
       return tokenizeExclamation(next);
     }
 
     if (identical(next, $OPEN_SQUARE_BRACKET)) {
       return tokenizeOpenSquareBracket(next);
     }
 
     if (identical(next, $CLOSE_SQUARE_BRACKET)) {
       return appendEndGroup(
-          CLOSE_SQUARE_BRACKET_INFO, OPEN_SQUARE_BRACKET_TOKEN);
+          TokenType.CLOSE_SQUARE_BRACKET, OPEN_SQUARE_BRACKET_TOKEN);
     }
 
     if (identical(next, $AT)) {
       return tokenizeAt(next);
     }
 
     if (next >= $1 && next <= $9) {
       return tokenizeNumber(next);
     }
 
@@ skipping 35 matching lines @@
 
     if (identical(next, $TILDE)) {
       return tokenizeTilde(next);
     }
 
     if (identical(next, $PERCENT)) {
       return tokenizePercent(next);
     }
 
     if (identical(next, $BACKPING)) {
-      appendPrecedenceToken(BACKPING_INFO);
+      appendPrecedenceToken(TokenType.BACKPING);
       return advance();
     }
 
     if (identical(next, $BACKSLASH)) {
-      appendPrecedenceToken(BACKSLASH_INFO);
+      appendPrecedenceToken(TokenType.BACKSLASH);
       return advance();
     }
 
     if (identical(next, $HASH)) {
       return tokenizeTag(next);
     }
 
     if (next < 0x1f) {
       return unexpected(next);
     }
 
     next = currentAsUnicode(next);
 
     return unexpected(next);
   }
 
   int tokenizeTag(int next) {
     // # or #!.*[\n\r]
     if (scanOffset == 0) {
       if (identical(peek(), $BANG)) {
         int start = scanOffset;
         bool asciiOnly = true;
         do {
           next = advance();
           if (next > 127) asciiOnly = false;
         } while (!identical(next, $LF) &&
             !identical(next, $CR) &&
             !identical(next, $EOF));
         if (!asciiOnly) handleUnicode(start);
-        appendSubstringToken(SCRIPT_INFO, start, asciiOnly);
+        appendSubstringToken(TokenType.SCRIPT_TAG, start, asciiOnly);
         return next;
       }
     }
-    appendPrecedenceToken(HASH_INFO);
+    appendPrecedenceToken(TokenType.HASH);
     return advance();
   }
 
   int tokenizeTilde(int next) {
     // ~ ~/ ~/=
     next = advance();
     if (identical(next, $SLASH)) {
-      return select($EQ, TILDE_SLASH_EQ_INFO, TILDE_SLASH_INFO);
+      return select($EQ, TokenType.TILDE_SLASH_EQ, TokenType.TILDE_SLASH);
     } else {
-      appendPrecedenceToken(TILDE_INFO);
+      appendPrecedenceToken(TokenType.TILDE);
       return next;
     }
   }
 
   int tokenizeOpenSquareBracket(int next) {
     // [ [] []=
     next = advance();
     if (identical(next, $CLOSE_SQUARE_BRACKET)) {
-      return select($EQ, INDEX_EQ_INFO, INDEX_INFO);
+      return select($EQ, TokenType.INDEX_EQ, TokenType.INDEX);
     }
-    appendBeginGroup(OPEN_SQUARE_BRACKET_INFO);
+    appendBeginGroup(TokenType.OPEN_SQUARE_BRACKET);
     return next;
   }
 
   int tokenizeCaret(int next) {
     // ^ ^=
-    return select($EQ, CARET_EQ_INFO, CARET_INFO);
+    return select($EQ, TokenType.CARET_EQ, TokenType.CARET);
   }
 
   int tokenizeQuestion(int next) {
     // ? ?. ?? ??=
     next = advance();
     if (identical(next, $QUESTION)) {
-      return select($EQ, QUESTION_QUESTION_EQ_INFO, QUESTION_QUESTION_INFO);
+      return select(
+          $EQ, TokenType.QUESTION_QUESTION_EQ, TokenType.QUESTION_QUESTION);
     } else if (identical(next, $PERIOD)) {
-      appendPrecedenceToken(QUESTION_PERIOD_INFO);
+      appendPrecedenceToken(TokenType.QUESTION_PERIOD);
       return advance();
     } else {
-      appendPrecedenceToken(QUESTION_INFO);
+      appendPrecedenceToken(TokenType.QUESTION);
       return next;
     }
   }
 
   int tokenizeBar(int next) {
     // | || |=
     next = advance();
     if (identical(next, $BAR)) {
-      appendPrecedenceToken(BAR_BAR_INFO);
+      appendPrecedenceToken(TokenType.BAR_BAR);
       return advance();
     } else if (identical(next, $EQ)) {
-      appendPrecedenceToken(BAR_EQ_INFO);
+      appendPrecedenceToken(TokenType.BAR_EQ);
       return advance();
     } else {
-      appendPrecedenceToken(BAR_INFO);
+      appendPrecedenceToken(TokenType.BAR);
       return next;
     }
   }
 
   int tokenizeAmpersand(int next) {
     // && &= &
     next = advance();
     if (identical(next, $AMPERSAND)) {
-      appendPrecedenceToken(AMPERSAND_AMPERSAND_INFO);
+      appendPrecedenceToken(TokenType.AMPERSAND_AMPERSAND);
       return advance();
     } else if (identical(next, $EQ)) {
-      appendPrecedenceToken(AMPERSAND_EQ_INFO);
+      appendPrecedenceToken(TokenType.AMPERSAND_EQ);
       return advance();
     } else {
-      appendPrecedenceToken(AMPERSAND_INFO);
+      appendPrecedenceToken(TokenType.AMPERSAND);
       return next;
     }
   }
 
   int tokenizePercent(int next) {
     // % %=
-    return select($EQ, PERCENT_EQ_INFO, PERCENT_INFO);
+    return select($EQ, TokenType.PERCENT_EQ, TokenType.PERCENT);
   }
 
   int tokenizeMultiply(int next) {
     // * *=
-    return select($EQ, STAR_EQ_INFO, STAR_INFO);
+    return select($EQ, TokenType.STAR_EQ, TokenType.STAR);
   }
 
   int tokenizeMinus(int next) {
     // - -- -=
     next = advance();
     if (identical(next, $MINUS)) {
-      appendPrecedenceToken(MINUS_MINUS_INFO);
+      appendPrecedenceToken(TokenType.MINUS_MINUS);
       return advance();
     } else if (identical(next, $EQ)) {
-      appendPrecedenceToken(MINUS_EQ_INFO);
+      appendPrecedenceToken(TokenType.MINUS_EQ);
       return advance();
     } else {
-      appendPrecedenceToken(MINUS_INFO);
+      appendPrecedenceToken(TokenType.MINUS);
       return next;
     }
   }
 
   int tokenizePlus(int next) {
     // + ++ +=
     next = advance();
     if (identical($PLUS, next)) {
-      appendPrecedenceToken(PLUS_PLUS_INFO);
+      appendPrecedenceToken(TokenType.PLUS_PLUS);
       return advance();
     } else if (identical($EQ, next)) {
-      appendPrecedenceToken(PLUS_EQ_INFO);
+      appendPrecedenceToken(TokenType.PLUS_EQ);
       return advance();
     } else {
-      appendPrecedenceToken(PLUS_INFO);
+      appendPrecedenceToken(TokenType.PLUS);
       return next;
     }
   }
 
   int tokenizeExclamation(int next) {
     // ! !=
     // !== is kept for user-friendly error reporting.
 
     next = advance();
     if (identical(next, $EQ)) {
-      return select($EQ, BANG_EQ_EQ_INFO, BANG_EQ_INFO);
+      return select($EQ, TokenType.BANG_EQ_EQ, TokenType.BANG_EQ);
     }
-    appendPrecedenceToken(BANG_INFO);
+    appendPrecedenceToken(TokenType.BANG);
     return next;
   }
 
   int tokenizeEquals(int next) {
     // = == =>
     // === is kept for user-friendly error reporting.
 
     // Type parameters and arguments cannot contain any token that
     // starts with '='.
     discardOpenLt();
 
     next = advance();
     if (identical(next, $EQ)) {
-      return select($EQ, EQ_EQ_EQ_INFO, EQ_EQ_INFO);
+      return select($EQ, TokenType.EQ_EQ_EQ, TokenType.EQ_EQ);
     } else if (identical(next, $GT)) {
-      appendPrecedenceToken(FUNCTION_INFO);
+      appendPrecedenceToken(TokenType.FUNCTION);
       return advance();
     }
-    appendPrecedenceToken(EQ_INFO);
+    appendPrecedenceToken(TokenType.EQ);
     return next;
   }
 
   int tokenizeGreaterThan(int next) {
     // > >= >> >>=
     next = advance();
     if (identical($EQ, next)) {
-      appendPrecedenceToken(GT_EQ_INFO);
+      appendPrecedenceToken(TokenType.GT_EQ);
       return advance();
     } else if (identical($GT, next)) {
       next = advance();
       if (identical($EQ, next)) {
-        appendPrecedenceToken(GT_GT_EQ_INFO);
+        appendPrecedenceToken(TokenType.GT_GT_EQ);
         return advance();
       } else {
-        appendGtGt(GT_GT_INFO);
+        appendGtGt(TokenType.GT_GT);
         return next;
       }
     } else {
-      appendGt(GT_INFO);
+      appendGt(TokenType.GT);
       return next;
     }
   }
 
   int tokenizeLessThan(int next) {
     // < <= << <<=
     next = advance();
     if (identical($EQ, next)) {
-      appendPrecedenceToken(LT_EQ_INFO);
+      appendPrecedenceToken(TokenType.LT_EQ);
       return advance();
     } else if (identical($LT, next)) {
-      return select($EQ, LT_LT_EQ_INFO, LT_LT_INFO);
+      return select($EQ, TokenType.LT_LT_EQ, TokenType.LT_LT);
     } else {
-      appendBeginGroup(LT_INFO);
+      appendBeginGroup(TokenType.LT);
       return next;
     }
   }
 
   int tokenizeNumber(int next) {
     int start = scanOffset;
     while (true) {
       next = advance();
       if ($0 <= next && next <= $9) {
         continue;
       } else if (identical(next, $e) || identical(next, $E)) {
         return tokenizeFractionPart(next, start);
       } else {
         if (identical(next, $PERIOD)) {
           int nextnext = peek();
           if ($0 <= nextnext && nextnext <= $9) {
             return tokenizeFractionPart(advance(), start);
           }
         }
-        appendSubstringToken(INT_INFO, start, true);
+        appendSubstringToken(TokenType.INT, start, true);
         return next;
       }
     }
   }
 
   int tokenizeHexOrNumber(int next) {
     int x = peek();
     if (identical(x, $x) || identical(x, $X)) {
       return tokenizeHex(next);
     }
     return tokenizeNumber(next);
   }
 
   int tokenizeHex(int next) {
     int start = scanOffset;
     next = advance(); // Advance past the $x or $X.
     bool hasDigits = false;
     while (true) {
       next = advance();
       if (($0 <= next && next <= $9) ||
           ($A <= next && next <= $F) ||
           ($a <= next && next <= $f)) {
         hasDigits = true;
       } else {
         if (!hasDigits) {
           unterminated('0x', shouldAdvance: false);
           return next;
         }
-        appendSubstringToken(HEXADECIMAL_INFO, start, true);
+        appendSubstringToken(TokenType.HEXADECIMAL, start, true);
         return next;
       }
     }
   }
 
   int tokenizeDotsOrNumber(int next) {
     int start = scanOffset;
     next = advance();
     if (($0 <= next && next <= $9)) {
       return tokenizeFractionPart(next, start);
     } else if (identical($PERIOD, next)) {
-      return select($PERIOD, PERIOD_PERIOD_PERIOD_INFO, PERIOD_PERIOD_INFO);
+      return select(
+          $PERIOD, TokenType.PERIOD_PERIOD_PERIOD, TokenType.PERIOD_PERIOD);
     } else {
-      appendPrecedenceToken(PERIOD_INFO);
+      appendPrecedenceToken(TokenType.PERIOD);
       return next;
     }
   }
 
   int tokenizeFractionPart(int next, int start) {
     bool done = false;
     bool hasDigit = false;
     LOOP:
     while (!done) {
       if ($0 <= next && next <= $9) {
@@ skipping 21 matching lines @@
         done = true;
         continue LOOP;
       } else {
         done = true;
         continue LOOP;
       }
       next = advance();
     }
     if (!hasDigit) {
       // Reduce offset, we already advanced to the token past the period.
-      appendSubstringToken(INT_INFO, start, true, -1);
+      appendSubstringToken(TokenType.INT, start, true, -1);
 
       // TODO(ahe): Wrong offset for the period. Cannot call beginToken because
       // the scanner already advanced past the period.
       if (identical($PERIOD, next)) {
-        return select($PERIOD, PERIOD_PERIOD_PERIOD_INFO, PERIOD_PERIOD_INFO);
+        return select(
+            $PERIOD, TokenType.PERIOD_PERIOD_PERIOD, TokenType.PERIOD_PERIOD);
       }
-      appendPrecedenceToken(PERIOD_INFO);
+      appendPrecedenceToken(TokenType.PERIOD);
       return next;
     }
-    appendSubstringToken(DOUBLE_INFO, start, true);
+    appendSubstringToken(TokenType.DOUBLE, start, true);
     return next;
   }
 
   int tokenizeSlashOrComment(int next) {
     int start = scanOffset;
     next = advance();
     if (identical($STAR, next)) {
       return tokenizeMultiLineComment(next, start);
     } else if (identical($SLASH, next)) {
       return tokenizeSingleLineComment(next, start);
     } else if (identical($EQ, next)) {
-      appendPrecedenceToken(SLASH_EQ_INFO);
+      appendPrecedenceToken(TokenType.SLASH_EQ);
       return advance();
     } else {
-      appendPrecedenceToken(SLASH_INFO);
+      appendPrecedenceToken(TokenType.SLASH);
       return next;
     }
   }
 
   int tokenizeSingleLineComment(int next, int start) {
     bool asciiOnly = true;
     bool dartdoc = identical($SLASH, peek());
     while (true) {
       next = advance();
       if (next > 127) asciiOnly = false;
       if (identical($LF, next) ||
           identical($CR, next) ||
           identical($EOF, next)) {
         if (!asciiOnly) handleUnicode(start);
         if (dartdoc) {
-          appendDartDoc(start, SINGLE_LINE_COMMENT_INFO, asciiOnly);
+          appendDartDoc(start, TokenType.SINGLE_LINE_COMMENT, asciiOnly);
         } else {
-          appendComment(start, SINGLE_LINE_COMMENT_INFO, asciiOnly);
+          appendComment(start, TokenType.SINGLE_LINE_COMMENT, asciiOnly);
         }
         return next;
       }
     }
   }
 
   int tokenizeMultiLineComment(int next, int start) {
     bool asciiOnlyComment = true; // Track if the entire comment is ASCII.
     bool asciiOnlyLines = true; // Track ASCII since the last handleUnicode.
     int unicodeStart = start;
     int nesting = 1;
     next = advance();
     bool dartdoc = identical($STAR, next);
     while (true) {
       if (identical($EOF, next)) {
         if (!asciiOnlyLines) handleUnicode(unicodeStart);
         unterminated('/*');
         break;
       } else if (identical($STAR, next)) {
         next = advance();
         if (identical($SLASH, next)) {
           --nesting;
           if (0 == nesting) {
             if (!asciiOnlyLines) handleUnicode(unicodeStart);
             next = advance();
             if (dartdoc) {
-              appendDartDoc(start, MULTI_LINE_COMMENT_INFO, asciiOnlyComment);
+              appendDartDoc(
+                  start, TokenType.MULTI_LINE_COMMENT, asciiOnlyComment);
             } else {
-              appendComment(start, MULTI_LINE_COMMENT_INFO, asciiOnlyComment);
+              appendComment(
+                  start, TokenType.MULTI_LINE_COMMENT, asciiOnlyComment);
             }
             break;
           } else {
             next = advance();
           }
         }
       } else if (identical($SLASH, next)) {
         next = advance();
         if (identical($STAR, next)) {
           next = advance();
@@ skipping 23 matching lines @@
     if (!includeComments) return;
     CommentToken newComment = createCommentToken(info, start, asciiOnly);
     if (scanGenericMethodComments) {
       String value = newComment.lexeme;
       int length = value.length;
       if (length > 5 &&
           value.codeUnitAt(0) == $SLASH &&
           value.codeUnitAt(1) == $STAR &&
           value.codeUnitAt(2) == $EQ) {
         newComment = new CommentToken.fromString(
-            GENERIC_METHOD_TYPE_ASSIGN, value, start);
+            TokenType.GENERIC_METHOD_TYPE_ASSIGN, value, start);
       } else if (length > 6 &&
           value.codeUnitAt(0) == $SLASH &&
           value.codeUnitAt(1) == $STAR &&
           value.codeUnitAt(2) == $LT &&
           value.codeUnitAt(length - 1) == $SLASH &&
           value.codeUnitAt(length - 2) == $STAR &&
           value.codeUnitAt(length - 3) == $GT) {
-        newComment =
-            new CommentToken.fromString(GENERIC_METHOD_TYPE_LIST, value, start);
+        newComment = new CommentToken.fromString(
+            TokenType.GENERIC_METHOD_TYPE_LIST, value, start);
       }
     }
     _appendToCommentStream(newComment);
   }
 
   void appendDartDoc(int start, TokenType info, bool asciiOnly) {
     if (!includeComments) return;
     Token newComment = createDartDocToken(info, start, asciiOnly);
     _appendToCommentStream(newComment);
   }
@@ skipping 78 matching lines @@
           ($A <= next && next <= $Z) ||
           ($0 <= next && next <= $9) ||
           identical(next, $_) ||
           (identical(next, $$) && allowDollar)) {
         next = advance();
       } else {
         // Identifier ends here.
         if (start == scanOffset) {
           return unexpected(next);
         } else {
-          appendSubstringToken(IDENTIFIER_INFO, start, true);
+          appendSubstringToken(TokenType.IDENTIFIER, start, true);
         }
         break;
       }
     }
     return next;
   }
 
   int tokenizeAt(int next) {
-    appendPrecedenceToken(AT_INFO);
+    appendPrecedenceToken(TokenType.AT);
     return advance();
   }
 
   int tokenizeString(int next, int start, bool raw) {
     int quoteChar = next;
     next = advance();
     if (identical(quoteChar, next)) {
       next = advance();
       if (identical(quoteChar, next)) {
         // Multiline string.
         return tokenizeMultiLineString(quoteChar, start, raw);
       } else {
         // Empty string.
-        appendSubstringToken(STRING_INFO, start, true);
+        appendSubstringToken(TokenType.STRING, start, true);
         return next;
       }
     }
     if (raw) {
       return tokenizeSingleLineRawString(next, quoteChar, start);
     } else {
       return tokenizeSingleLineString(next, quoteChar, start);
     }
   }
 
@@ skipping 27 matching lines @@
               identical(next, $EOF))) {
         if (!asciiOnly) handleUnicode(start);
         return unterminatedString(quoteChar);
       }
       if (next > 127) asciiOnly = false;
       next = advance();
     }
     if (!asciiOnly) handleUnicode(start);
     // Advance past the quote character.
     next = advance();
-    appendSubstringToken(STRING_INFO, start, asciiOnly);
+    appendSubstringToken(TokenType.STRING, start, asciiOnly);
     return next;
   }
 
   int tokenizeStringInterpolation(int start, bool asciiOnly) {
-    appendSubstringToken(STRING_INFO, start, asciiOnly);
+    appendSubstringToken(TokenType.STRING, start, asciiOnly);
     beginToken(); // $ starts here.
     int next = advance();
     if (identical(next, $OPEN_CURLY_BRACKET)) {
       return tokenizeInterpolatedExpression(next);
     } else {
       return tokenizeInterpolatedIdentifier(next);
     }
   }
 
   int tokenizeInterpolatedExpression(int next) {
-    appendBeginGroup(STRING_INTERPOLATION_INFO);
+    appendBeginGroup(TokenType.STRING_INTERPOLATION_EXPRESSION);
     beginToken(); // The expression starts here.
     next = advance(); // Move past the curly bracket.
     while (!identical(next, $EOF) && !identical(next, $STX)) {
       next = bigSwitch(next);
     }
     if (identical(next, $EOF)) return next;
     next = advance(); // Move past the $STX.
     beginToken(); // The string interpolation suffix starts here.
     return next;
   }
 
   int tokenizeInterpolatedIdentifier(int next) {
-    appendPrecedenceToken(STRING_INTERPOLATION_IDENTIFIER_INFO);
+    appendPrecedenceToken(TokenType.STRING_INTERPOLATION_IDENTIFIER);
 
     if ($a <= next && next <= $z ||
         $A <= next && next <= $Z ||
         identical(next, $_)) {
       beginToken(); // The identifier starts here.
       next = tokenizeKeywordOrIdentifier(next, false);
     } else {
       unterminated(r'$', shouldAdvance: false);
     }
     beginToken(); // The string interpolation suffix starts here.
     return next;
   }
 
   int tokenizeSingleLineRawString(int next, int quoteChar, int start) {
     bool asciiOnly = true;
     while (next != $EOF) {
       if (identical(next, quoteChar)) {
         if (!asciiOnly) handleUnicode(start);
         next = advance();
-        appendSubstringToken(STRING_INFO, start, asciiOnly);
+        appendSubstringToken(TokenType.STRING, start, asciiOnly);
         return next;
       } else if (identical(next, $LF) || identical(next, $CR)) {
         if (!asciiOnly) handleUnicode(start);
         return unterminatedRawString(quoteChar);
       } else if (next > 127) {
         asciiOnly = false;
       }
       next = advance();
     }
     if (!asciiOnly) handleUnicode(start);
@@ skipping 22 matching lines @@
         }
         next = advance();
         if (identical(next, $EOF)) break outer;
       }
       next = advance();
       if (identical(next, quoteChar)) {
         next = advance();
         if (identical(next, quoteChar)) {
           if (!asciiOnlyLine) handleUnicode(unicodeStart);
           next = advance();
-          appendSubstringToken(STRING_INFO, start, asciiOnlyString);
+          appendSubstringToken(TokenType.STRING, start, asciiOnlyString);
           return next;
         }
       }
     }
     if (!asciiOnlyLine) handleUnicode(unicodeStart);
     return unterminatedRawMultiLineString(quoteChar);
   }
 
   int tokenizeMultiLineString(int quoteChar, int start, bool raw) {
     if (raw) return tokenizeMultiLineRawString(quoteChar, start);
@@ skipping 11 matching lines @@
         asciiOnlyLine = true;
         continue;
       }
       if (identical(next, quoteChar)) {
         next = advance();
         if (identical(next, quoteChar)) {
           next = advance();
           if (identical(next, quoteChar)) {
             if (!asciiOnlyLine) handleUnicode(unicodeStart);
             next = advance();
-            appendSubstringToken(STRING_INFO, start, asciiOnlyString);
+            appendSubstringToken(TokenType.STRING, start, asciiOnlyString);
             return next;
           }
         }
         continue;
       }
       if (identical(next, $BACKSLASH)) {
         next = advance();
         if (identical(next, $EOF)) break;
       }
       if (identical(next, $LF)) {
@@ skipping 47 matching lines @@
     if (shouldAdvance) {
       return advance(); // Ensure progress.
     } else {
       return -1;
     }
   }
 }
 
 TokenType closeBraceInfoFor(BeginGroupToken begin) {
   return const {
-    '(': CLOSE_PAREN_INFO,
-    '[': CLOSE_SQUARE_BRACKET_INFO,
-    '{': CLOSE_CURLY_BRACKET_INFO,
-    '<': GT_INFO,
-    r'${': CLOSE_CURLY_BRACKET_INFO,
+    '(': TokenType.CLOSE_PAREN,
+    '[': TokenType.CLOSE_SQUARE_BRACKET,
+    '{': TokenType.CLOSE_CURLY_BRACKET,
+    '<': TokenType.GT,
+    r'${': TokenType.CLOSE_CURLY_BRACKET,
   }[begin.lexeme];
 }
 
 class LineStarts extends Object with ListMixin<int> {
   List<int> array;
   int arrayLength = 0;
 
   LineStarts(int numberOfBytesHint) {
     // Let's assume the average Dart file is 300 bytes.
     if (numberOfBytesHint == null) numberOfBytesHint = 300;
@@ skipping 59 matching lines @@
       switchToUint32(newLength);
     }
   }
 
   void switchToUint32(int newLength) {
     final newArray = new Uint32List(newLength);
     newArray.setRange(0, arrayLength, array);
     array = newArray;
   }
 }