merge PrecedenceInfo into TokenType and update all refs

pkg/analyzer/lib/src/fasta/token_utils.dart

 // Copyright (c) 2016, 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.analyzer.token_utils;
 
 import 'package:front_end/src/fasta/scanner/error_token.dart' show ErrorToken;
 
 import 'package:front_end/src/scanner/token.dart' show Keyword;
 
-import 'package:front_end/src/fasta/scanner/precedence.dart';
-
 import 'package:front_end/src/fasta/scanner/token.dart'
     show
         BeginGroupToken,
         CommentToken,
         DartDocToken,
         KeywordToken,
         StringToken,
         SymbolToken,
         Token;
 
@@ skipping 138 matching lines @@
         token.endGroup.charOffset != token.charOffset) {
       _beginTokenStack.add(translatedToken);
       _endTokenStack.add(token.endGroup);
     }
   }
 }
 
 /// Converts a single Fasta comment token to an analyzer comment token.
 analyzer.CommentToken toAnalyzerCommentToken(Token token) {
   TokenType type;
-  if (token.type == GENERIC_METHOD_TYPE_ASSIGN) {
+  if (token.type == TokenType.GENERIC_METHOD_TYPE_ASSIGN) {
     type = TokenType.GENERIC_METHOD_TYPE_ASSIGN;
-  } else if (token.type == GENERIC_METHOD_TYPE_LIST) {
+  } else if (token.type == TokenType.GENERIC_METHOD_TYPE_LIST) {
     type = TokenType.GENERIC_METHOD_TYPE_LIST;
   } else {
     // TODO(paulberry,ahe): It would be nice if the scanner gave us an
     // easier way to distinguish between the two types of comment.
     type = token.lexeme.startsWith('/*')
         ? TokenType.MULTI_LINE_COMMENT
         : TokenType.SINGLE_LINE_COMMENT;
   }
   return new analyzer.CommentToken(type, token.lexeme, token.charOffset);
 }
@@ skipping 92 matching lines @@
 }
 
 /// Converts a single analyzer token into a Fasta token.
 Token fromAnalyzerToken(analyzer.Token token) {
   Token beginGroup(TokenType info) => new BeginGroupToken(info, token.offset);
   Token string(TokenType info) =>
       new StringToken.fromString(info, token.lexeme, token.offset);
   Token symbol(TokenType info) => new SymbolToken(info, token.offset);
   switch (token.type) {
     case TokenType.DOUBLE:
-      return string(DOUBLE_INFO);
+      return string(TokenType.DOUBLE);
     case TokenType.HEXADECIMAL:
-      return string(HEXADECIMAL_INFO);
+      return string(TokenType.HEXADECIMAL);
     case TokenType.IDENTIFIER:
       // Certain identifiers have special grammatical meanings even though they
       // are neither keywords nor built-in identifiers (e.g. "async").  Analyzer
       // represents these as identifiers.  Fasta represents them as keywords
       // with the "isPseudo" property.
       var keyword = Keyword.keywords[token.lexeme];
       if (keyword != null) {
         assert(keyword.isPseudo);
         return new KeywordToken(keyword, token.offset);
       } else {
-        return string(IDENTIFIER_INFO);
+        return string(TokenType.IDENTIFIER);
       }
       break;
     case TokenType.INT:
-      return string(INT_INFO);
+      return string(TokenType.INT);
     case TokenType.KEYWORD:
       var keyword = Keyword.keywords[token.lexeme];
       if (keyword != null) {
         return new KeywordToken(keyword, token.offset);
       } else {
         return internalError("Unrecognized keyword: '${token.lexeme}'.");
       }
       break;
     case TokenType.MULTI_LINE_COMMENT:
       if (token.lexeme.startsWith('/**')) {
-        return new DartDocToken.fromSubstring(
-            MULTI_LINE_COMMENT_INFO, token.lexeme, 0, token.lexeme.length, 0);
+        return new DartDocToken.fromSubstring(TokenType.MULTI_LINE_COMMENT,
+            token.lexeme, 0, token.lexeme.length, 0);
       }
-      return new CommentToken.fromSubstring(
-          MULTI_LINE_COMMENT_INFO, token.lexeme, 0, token.lexeme.length, 0);
+      return new CommentToken.fromSubstring(TokenType.MULTI_LINE_COMMENT,
+          token.lexeme, 0, token.lexeme.length, 0);
     case TokenType.SCRIPT_TAG:
-      return string(SCRIPT_INFO);
+      return string(TokenType.SCRIPT_TAG);
     case TokenType.SINGLE_LINE_COMMENT:
       if (token.lexeme.startsWith('///')) {
-        return new DartDocToken.fromSubstring(
-            SINGLE_LINE_COMMENT_INFO, token.lexeme, 0, token.lexeme.length, 0);
+        return new DartDocToken.fromSubstring(TokenType.SINGLE_LINE_COMMENT,
+            token.lexeme, 0, token.lexeme.length, 0);
       }
-      return new CommentToken.fromSubstring(
-          SINGLE_LINE_COMMENT_INFO, token.lexeme, 0, token.lexeme.length, 0);
+      return new CommentToken.fromSubstring(TokenType.SINGLE_LINE_COMMENT,
+          token.lexeme, 0, token.lexeme.length, 0);
     case TokenType.STRING:
-      return string(STRING_INFO);
+      return string(TokenType.STRING);
     case TokenType.AMPERSAND:
-      return symbol(AMPERSAND_INFO);
+      return symbol(TokenType.AMPERSAND);
     case TokenType.AMPERSAND_AMPERSAND:
-      return symbol(AMPERSAND_AMPERSAND_INFO);
+      return symbol(TokenType.AMPERSAND_AMPERSAND);
     // case TokenType.AMPERSAND_AMPERSAND_EQ
     case TokenType.AMPERSAND_EQ:
-      return symbol(AMPERSAND_EQ_INFO);
+      return symbol(TokenType.AMPERSAND_EQ);
     case TokenType.AT:
-      return symbol(AT_INFO);
+      return symbol(TokenType.AT);
     case TokenType.BANG:
-      return symbol(BANG_INFO);
+      return symbol(TokenType.BANG);
     case TokenType.BANG_EQ:
-      return symbol(BANG_EQ_INFO);
+      return symbol(TokenType.BANG_EQ);
     case TokenType.BAR:
-      return symbol(BAR_INFO);
+      return symbol(TokenType.BAR);
     case TokenType.BAR_BAR:
-      return symbol(BAR_BAR_INFO);
+      return symbol(TokenType.BAR_BAR);
     // case TokenType.BAR_BAR_EQ
     case TokenType.BAR_EQ:
-      return symbol(BAR_EQ_INFO);
+      return symbol(TokenType.BAR_EQ);
     case TokenType.COLON:
-      return symbol(COLON_INFO);
+      return symbol(TokenType.COLON);
     case TokenType.COMMA:
-      return symbol(COMMA_INFO);
+      return symbol(TokenType.COMMA);
     case TokenType.CARET:
-      return symbol(CARET_INFO);
+      return symbol(TokenType.CARET);
     case TokenType.CARET_EQ:
-      return symbol(CARET_EQ_INFO);
+      return symbol(TokenType.CARET_EQ);
     case TokenType.CLOSE_CURLY_BRACKET:
-      return symbol(CLOSE_CURLY_BRACKET_INFO);
+      return symbol(TokenType.CLOSE_CURLY_BRACKET);
     case TokenType.CLOSE_PAREN:
-      return symbol(CLOSE_PAREN_INFO);
+      return symbol(TokenType.CLOSE_PAREN);
     case TokenType.CLOSE_SQUARE_BRACKET:
-      return symbol(CLOSE_SQUARE_BRACKET_INFO);
+      return symbol(TokenType.CLOSE_SQUARE_BRACKET);
     case TokenType.EQ:
-      return symbol(EQ_INFO);
+      return symbol(TokenType.EQ);
     case TokenType.EQ_EQ:
-      return symbol(EQ_EQ_INFO);
+      return symbol(TokenType.EQ_EQ);
     case TokenType.FUNCTION:
-      return symbol(FUNCTION_INFO);
+      return symbol(TokenType.FUNCTION);
     case TokenType.GT:
-      return symbol(GT_INFO);
+      return symbol(TokenType.GT);
     case TokenType.GT_EQ:
-      return symbol(GT_EQ_INFO);
+      return symbol(TokenType.GT_EQ);
     case TokenType.GT_GT:
-      return symbol(GT_GT_INFO);
+      return symbol(TokenType.GT_GT);
     case TokenType.GT_GT_EQ:
-      return symbol(GT_GT_EQ_INFO);
+      return symbol(TokenType.GT_GT_EQ);
     case TokenType.HASH:
-      return symbol(HASH_INFO);
+      return symbol(TokenType.HASH);
     case TokenType.INDEX:
-      return symbol(INDEX_INFO);
+      return symbol(TokenType.INDEX);
     case TokenType.INDEX_EQ:
-      return symbol(INDEX_EQ_INFO);
+      return symbol(TokenType.INDEX_EQ);
     case TokenType.LT:
-      return beginGroup(LT_INFO);
+      return beginGroup(TokenType.LT);
     case TokenType.LT_EQ:
-      return symbol(LT_EQ_INFO);
+      return symbol(TokenType.LT_EQ);
     case TokenType.LT_LT:
-      return symbol(LT_LT_INFO);
+      return symbol(TokenType.LT_LT);
     case TokenType.LT_LT_EQ:
-      return symbol(LT_LT_EQ_INFO);
+      return symbol(TokenType.LT_LT_EQ);
     case TokenType.MINUS:
-      return symbol(MINUS_INFO);
+      return symbol(TokenType.MINUS);
     case TokenType.MINUS_EQ:
-      return symbol(MINUS_EQ_INFO);
+      return symbol(TokenType.MINUS_EQ);
     case TokenType.MINUS_MINUS:
-      return symbol(MINUS_MINUS_INFO);
+      return symbol(TokenType.MINUS_MINUS);
     case TokenType.OPEN_CURLY_BRACKET:
-      return beginGroup(OPEN_CURLY_BRACKET_INFO);
+      return beginGroup(TokenType.OPEN_CURLY_BRACKET);
     case TokenType.OPEN_PAREN:
-      return beginGroup(OPEN_PAREN_INFO);
+      return beginGroup(TokenType.OPEN_PAREN);
     case TokenType.OPEN_SQUARE_BRACKET:
-      return beginGroup(OPEN_SQUARE_BRACKET_INFO);
+      return beginGroup(TokenType.OPEN_SQUARE_BRACKET);
     case TokenType.PERCENT:
-      return symbol(PERCENT_INFO);
+      return symbol(TokenType.PERCENT);
     case TokenType.PERCENT_EQ:
-      return symbol(PERCENT_EQ_INFO);
+      return symbol(TokenType.PERCENT_EQ);
     case TokenType.PERIOD:
-      return symbol(PERIOD_INFO);
+      return symbol(TokenType.PERIOD);
     case TokenType.PERIOD_PERIOD:
-      return symbol(PERIOD_PERIOD_INFO);
+      return symbol(TokenType.PERIOD_PERIOD);
     case TokenType.PLUS:
-      return symbol(PLUS_INFO);
+      return symbol(TokenType.PLUS);
     case TokenType.PLUS_EQ:
-      return symbol(PLUS_EQ_INFO);
+      return symbol(TokenType.PLUS_EQ);
     case TokenType.PLUS_PLUS:
-      return symbol(PLUS_PLUS_INFO);
+      return symbol(TokenType.PLUS_PLUS);
     case TokenType.QUESTION:
-      return symbol(QUESTION_INFO);
+      return symbol(TokenType.QUESTION);
     case TokenType.QUESTION_PERIOD:
-      return symbol(QUESTION_PERIOD_INFO);
+      return symbol(TokenType.QUESTION_PERIOD);
     case TokenType.QUESTION_QUESTION:
-      return symbol(QUESTION_QUESTION_INFO);
+      return symbol(TokenType.QUESTION_QUESTION);
     case TokenType.QUESTION_QUESTION_EQ:
-      return symbol(QUESTION_QUESTION_EQ_INFO);
+      return symbol(TokenType.QUESTION_QUESTION_EQ);
     case TokenType.SEMICOLON:
-      return symbol(SEMICOLON_INFO);
+      return symbol(TokenType.SEMICOLON);
     case TokenType.SLASH:
-      return symbol(SLASH_INFO);
+      return symbol(TokenType.SLASH);
     case TokenType.SLASH_EQ:
-      return symbol(SLASH_EQ_INFO);
+      return symbol(TokenType.SLASH_EQ);
     case TokenType.STAR:
-      return symbol(STAR_INFO);
+      return symbol(TokenType.STAR);
     case TokenType.STAR_EQ:
-      return symbol(STAR_EQ_INFO);
+      return symbol(TokenType.STAR_EQ);
     case TokenType.STRING_INTERPOLATION_EXPRESSION:
-      return beginGroup(STRING_INTERPOLATION_INFO);
+      return beginGroup(TokenType.STRING_INTERPOLATION_EXPRESSION);
     case TokenType.STRING_INTERPOLATION_IDENTIFIER:
-      return symbol(STRING_INTERPOLATION_IDENTIFIER_INFO);
+      return symbol(TokenType.STRING_INTERPOLATION_IDENTIFIER);
     case TokenType.TILDE:
-      return symbol(TILDE_INFO);
+      return symbol(TokenType.TILDE);
     case TokenType.TILDE_SLASH:
-      return symbol(TILDE_SLASH_INFO);
+      return symbol(TokenType.TILDE_SLASH);
     case TokenType.TILDE_SLASH_EQ:
-      return symbol(TILDE_SLASH_EQ_INFO);
+      return symbol(TokenType.TILDE_SLASH_EQ);
     case TokenType.BACKPING:
-      return symbol(BACKPING_INFO);
+      return symbol(TokenType.BACKPING);
     case TokenType.BACKSLASH:
-      return symbol(BACKSLASH_INFO);
+      return symbol(TokenType.BACKSLASH);
     case TokenType.PERIOD_PERIOD_PERIOD:
-      return symbol(PERIOD_PERIOD_PERIOD_INFO);
+      return symbol(TokenType.PERIOD_PERIOD_PERIOD);
     // case TokenType.GENERIC_METHOD_TYPE_ASSIGN
     // case TokenType.GENERIC_METHOD_TYPE_LIST
     default:
       return internalError('Unhandled token type ${token.type}');
   }
 }
 
 analyzer.Token toAnalyzerToken(Token token,
     [analyzer.CommentToken commentToken]) {
   if (token == null) return null;
@@ skipping 50 matching lines @@
     case SCRIPT_TOKEN:
       return makeStringToken(TokenType.SCRIPT_TAG);
 
     case STRING_TOKEN:
       return makeStringToken(TokenType.STRING);
 
     case OPEN_CURLY_BRACKET_TOKEN:
     case OPEN_SQUARE_BRACKET_TOKEN:
     case OPEN_PAREN_TOKEN:
     case STRING_INTERPOLATION_TOKEN:
-      return makeBeginToken(getTokenType(token));
+      return makeBeginToken(token.type);
 
     default:
       if (commentToken == null) {
-        return new analyzer.Token(getTokenType(token), token.charOffset);
+        return new analyzer.Token(token.type, token.charOffset);
       } else {
         return new analyzer.TokenWithComment(
-            getTokenType(token), token.charOffset, commentToken);
+            token.type, token.charOffset, commentToken);
       }
       break;
   }
 }
 
 final _keywordMap = {
   "assert": analyzer.Keyword.ASSERT,
   "break": analyzer.Keyword.BREAK,
   "case": analyzer.Keyword.CASE,
   "catch": analyzer.Keyword.CATCH,
@@ skipping 52 matching lines @@
   "hide": analyzer.Keyword.HIDE,
   "native": analyzer.Keyword.NATIVE,
   "of": analyzer.Keyword.OF,
   "on": analyzer.Keyword.ON,
   "patch": analyzer.Keyword.PATCH,
   "show": analyzer.Keyword.SHOW,
   "source": analyzer.Keyword.SOURCE,
   "sync": analyzer.Keyword.SYNC,
   "yield": analyzer.Keyword.YIELD,
 };
-
-TokenType getTokenType(Token token) {
-  switch (token.kind) {
-    case EOF_TOKEN:
-      return TokenType.EOF;
-    case DOUBLE_TOKEN:
-      return TokenType.DOUBLE;
-    case HEXADECIMAL_TOKEN:
-      return TokenType.HEXADECIMAL;
-    case IDENTIFIER_TOKEN:
-      return TokenType.IDENTIFIER;
-    case INT_TOKEN:
-      return TokenType.INT;
-    case KEYWORD_TOKEN:
-      return TokenType.KEYWORD;
-    // case MULTI_LINE_COMMENT_TOKEN: return TokenType.MULTI_LINE_COMMENT;
-    // case SCRIPT_TAG_TOKEN: return TokenType.SCRIPT_TAG;
-    // case SINGLE_LINE_COMMENT_TOKEN: return TokenType.SINGLE_LINE_COMMENT;
-    case STRING_TOKEN:
-      return TokenType.STRING;
-    case AMPERSAND_TOKEN:
-      return TokenType.AMPERSAND;
-    case AMPERSAND_AMPERSAND_TOKEN:
-      return TokenType.AMPERSAND_AMPERSAND;
-    // case AMPERSAND_AMPERSAND_EQ_TOKEN:
-    //   return TokenType.AMPERSAND_AMPERSAND_EQ;
-    case AMPERSAND_EQ_TOKEN:
-      return TokenType.AMPERSAND_EQ;
-    case AT_TOKEN:
-      return TokenType.AT;
-    case BANG_TOKEN:
-      return TokenType.BANG;
-    case BANG_EQ_TOKEN:
-      return TokenType.BANG_EQ;
-    case BAR_TOKEN:
-      return TokenType.BAR;
-    case BAR_BAR_TOKEN:
-      return TokenType.BAR_BAR;
-    // case BAR_BAR_EQ_TOKEN: return TokenType.BAR_BAR_EQ;
-    case BAR_EQ_TOKEN:
-      return TokenType.BAR_EQ;
-    case COLON_TOKEN:
-      return TokenType.COLON;
-    case COMMA_TOKEN:
-      return TokenType.COMMA;
-    case CARET_TOKEN:
-      return TokenType.CARET;
-    case CARET_EQ_TOKEN:
-      return TokenType.CARET_EQ;
-    case CLOSE_CURLY_BRACKET_TOKEN:
-      return TokenType.CLOSE_CURLY_BRACKET;
-    case CLOSE_PAREN_TOKEN:
-      return TokenType.CLOSE_PAREN;
-    case CLOSE_SQUARE_BRACKET_TOKEN:
-      return TokenType.CLOSE_SQUARE_BRACKET;
-    case EQ_TOKEN:
-      return TokenType.EQ;
-    case EQ_EQ_TOKEN:
-      return TokenType.EQ_EQ;
-    case FUNCTION_TOKEN:
-      return TokenType.FUNCTION;
-    case GT_TOKEN:
-      return TokenType.GT;
-    case GT_EQ_TOKEN:
-      return TokenType.GT_EQ;
-    case GT_GT_TOKEN:
-      return TokenType.GT_GT;
-    case GT_GT_EQ_TOKEN:
-      return TokenType.GT_GT_EQ;
-    case HASH_TOKEN:
-      return TokenType.HASH;
-    case INDEX_TOKEN:
-      return TokenType.INDEX;
-    case INDEX_EQ_TOKEN:
-      return TokenType.INDEX_EQ;
-    // case IS_TOKEN: return TokenType.IS;
-    case LT_TOKEN:
-      return TokenType.LT;
-    case LT_EQ_TOKEN:
-      return TokenType.LT_EQ;
-    case LT_LT_TOKEN:
-      return TokenType.LT_LT;
-    case LT_LT_EQ_TOKEN:
-      return TokenType.LT_LT_EQ;
-    case MINUS_TOKEN:
-      return TokenType.MINUS;
-    case MINUS_EQ_TOKEN:
-      return TokenType.MINUS_EQ;
-    case MINUS_MINUS_TOKEN:
-      return TokenType.MINUS_MINUS;
-    case OPEN_CURLY_BRACKET_TOKEN:
-      return TokenType.OPEN_CURLY_BRACKET;
-    case OPEN_PAREN_TOKEN:
-      return TokenType.OPEN_PAREN;
-    case OPEN_SQUARE_BRACKET_TOKEN:
-      return TokenType.OPEN_SQUARE_BRACKET;
-    case PERCENT_TOKEN:
-      return TokenType.PERCENT;
-    case PERCENT_EQ_TOKEN:
-      return TokenType.PERCENT_EQ;
-    case PERIOD_TOKEN:
-      return TokenType.PERIOD;
-    case PERIOD_PERIOD_TOKEN:
-      return TokenType.PERIOD_PERIOD;
-    case PLUS_TOKEN:
-      return TokenType.PLUS;
-    case PLUS_EQ_TOKEN:
-      return TokenType.PLUS_EQ;
-    case PLUS_PLUS_TOKEN:
-      return TokenType.PLUS_PLUS;
-    case QUESTION_TOKEN:
-      return TokenType.QUESTION;
-    case QUESTION_PERIOD_TOKEN:
-      return TokenType.QUESTION_PERIOD;
-    case QUESTION_QUESTION_TOKEN:
-      return TokenType.QUESTION_QUESTION;
-    case QUESTION_QUESTION_EQ_TOKEN:
-      return TokenType.QUESTION_QUESTION_EQ;
-    case SEMICOLON_TOKEN:
-      return TokenType.SEMICOLON;
-    case SLASH_TOKEN:
-      return TokenType.SLASH;
-    case SLASH_EQ_TOKEN:
-      return TokenType.SLASH_EQ;
-    case STAR_TOKEN:
-      return TokenType.STAR;
-    case STAR_EQ_TOKEN:
-      return TokenType.STAR_EQ;
-    case STRING_INTERPOLATION_TOKEN:
-      return TokenType.STRING_INTERPOLATION_EXPRESSION;
-    case STRING_INTERPOLATION_IDENTIFIER_TOKEN:
-      return TokenType.STRING_INTERPOLATION_IDENTIFIER;
-    case TILDE_TOKEN:
-      return TokenType.TILDE;
-    case TILDE_SLASH_TOKEN:
-      return TokenType.TILDE_SLASH;
-    case TILDE_SLASH_EQ_TOKEN:
-      return TokenType.TILDE_SLASH_EQ;
-    case BACKPING_TOKEN:
-      return TokenType.BACKPING;
-    case BACKSLASH_TOKEN:
-      return TokenType.BACKSLASH;
-    case PERIOD_PERIOD_PERIOD_TOKEN:
-      return TokenType.PERIOD_PERIOD_PERIOD;
-    case GENERIC_METHOD_TYPE_LIST_TOKEN:
-      return TokenType.GENERIC_METHOD_TYPE_LIST;
-    case GENERIC_METHOD_TYPE_ASSIGN_TOKEN:
-      return TokenType.GENERIC_METHOD_TYPE_ASSIGN;
-    default:
-      return internalError("Unhandled token ${token.info}");
-  }
-}