merge PrecedenceInfo into TokenType and update all refs

pkg/compiler/lib/src/resolution/enum_creator.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.
 
 library dart2js.resolution.enum_creator;
 
 import '../common.dart';
 import '../common_elements.dart' show CommonElements;
 import '../elements/resolution_types.dart';
 import '../elements/elements.dart';
 import '../elements/modelx.dart';
 import 'package:front_end/src/fasta/scanner.dart';
-import 'package:front_end/src/fasta/scanner/precedence.dart' as Precedence;
 import 'package:front_end/src/scanner/token.dart' show TokenType;
 import '../tree/tree.dart';
 import '../util/util.dart';
 
 // TODO(johnniwinther): Merge functionality with the `TreePrinter`.
 class AstBuilder {
   final int charOffset;
 
   AstBuilder(this.charOffset);
 
@@ skipping 15 matching lines @@
     }
     return new Modifiers.withFlags(
         new NodeList(null, linkedList(identifiers), null, ''), flags);
   }
 
   Token keywordToken(String text) {
     return new KeywordToken(Keyword.keywords[text], charOffset);
   }
 
   Token stringToken(String text) {
-    return new StringToken.fromString(
-        Precedence.IDENTIFIER_INFO, text, charOffset);
+    return new StringToken.fromString(TokenType.IDENTIFIER, text, charOffset);
   }
 
   Token symbolToken(TokenType info) {
     return new SymbolToken(info, charOffset);
   }
 
   Identifier identifier(String text) {
     Keyword keyword = Keyword.keywords[text];
     Token token;
     if (keyword != null) {
       token = new KeywordToken(keyword, charOffset);
     } else {
       token = stringToken(text);
     }
     return new Identifier(token);
   }
 
   Link linkedList(List elements) {
     LinkBuilder builder = new LinkBuilder();
     elements.forEach((e) => builder.addLast(e));
     return builder.toLink();
   }
 
   NodeList argumentList(List<Node> nodes) {
-    return new NodeList(symbolToken(Precedence.OPEN_PAREN_INFO),
-        linkedList(nodes), symbolToken(Precedence.CLOSE_PAREN_INFO), ',');
+    return new NodeList(symbolToken(TokenType.OPEN_PAREN), linkedList(nodes),
+        symbolToken(TokenType.CLOSE_PAREN), ',');
   }
 
   Return returnStatement(Expression expression) {
-    return new Return(keywordToken('return'),
-        symbolToken(Precedence.SEMICOLON_INFO), expression);
+    return new Return(
+        keywordToken('return'), symbolToken(TokenType.SEMICOLON), expression);
   }
 
   FunctionExpression functionExpression(Modifiers modifiers, String name,
       NodeList typeVariables, NodeList argumentList, Statement body,
       [TypeAnnotation returnType]) {
     return new FunctionExpression(
         identifier(name),
         typeVariables,
         argumentList,
         body,
         returnType,
         modifiers,
         null, // Initializer.
         null, // get/set.
         null // Async modifier.
         );
   }
 
   EmptyStatement emptyStatement() {
-    return new EmptyStatement(symbolToken(Precedence.COMMA_INFO));
+    return new EmptyStatement(symbolToken(TokenType.COMMA));
   }
 
   LiteralInt literalInt(int value) {
     return new LiteralInt(stringToken('$value'), null);
   }
 
   LiteralString literalString(String text,
       {String prefix: '"', String suffix: '"'}) {
     return new LiteralString(
         stringToken('$prefix$text$suffix'), new DartString.literal(text));
   }
 
   LiteralList listLiteral(List<Node> elements, {bool isConst: false}) {
     return new LiteralList(
         null,
         new NodeList(
-            symbolToken(Precedence.OPEN_SQUARE_BRACKET_INFO),
+            symbolToken(TokenType.OPEN_SQUARE_BRACKET),
             linkedList(elements),
-            symbolToken(Precedence.CLOSE_SQUARE_BRACKET_INFO),
+            symbolToken(TokenType.CLOSE_SQUARE_BRACKET),
             ','),
         isConst ? keywordToken('const') : null);
   }
 
   Node createDefinition(Identifier name, Expression initializer) {
     if (initializer == null) return name;
-    return new SendSet(
-        null,
-        name,
-        new Operator(symbolToken(Precedence.EQ_INFO)),
+    return new SendSet(null, name, new Operator(symbolToken(TokenType.EQ)),
         new NodeList.singleton(initializer));
   }
 
   VariableDefinitions initializingFormal(String fieldName) {
     return new VariableDefinitions.forParameter(
         new NodeList.empty(),
         null,
         Modifiers.EMPTY,
         new NodeList.singleton(
             new Send(identifier('this'), identifier(fieldName))));
   }
 
   NewExpression newExpression(String typeName, NodeList arguments,
       {bool isConst: false}) {
     return new NewExpression(keywordToken(isConst ? 'const' : 'new'),
         new Send(null, identifier(typeName), arguments));
   }
 
   Send reference(Identifier identifier) {
     return new Send(null, identifier);
   }
 
   Send indexGet(Expression receiver, Expression index) {
-    return new Send(receiver, new Operator(symbolToken(Precedence.INDEX_INFO)),
+    return new Send(receiver, new Operator(symbolToken(TokenType.INDEX)),
         new NodeList.singleton(index));
   }
 
   LiteralMapEntry mapLiteralEntry(Expression key, Expression value) {
-    return new LiteralMapEntry(key, symbolToken(Precedence.COLON_INFO), value);
+    return new LiteralMapEntry(key, symbolToken(TokenType.COLON), value);
   }
 
   LiteralMap mapLiteral(List<LiteralMapEntry> entries, {bool isConst: false}) {
     return new LiteralMap(
         null, // Type arguments.
         new NodeList(
-            symbolToken(Precedence.OPEN_CURLY_BRACKET_INFO),
+            symbolToken(TokenType.OPEN_CURLY_BRACKET),
             linkedList(entries),
-            symbolToken(Precedence.CLOSE_CURLY_BRACKET_INFO),
+            symbolToken(TokenType.CLOSE_CURLY_BRACKET),
             ','),
         isConst ? keywordToken('const') : null);
   }
 }
 
 /// This class generates the model for an enum class.
 ///
 /// For instance
 ///
 ///     enum A { b, c, }
@@ skipping 134 matching lines @@
     EnumMethodElementX toString = new EnumMethodElementX(
         'toString', enumClass, Modifiers.EMPTY, toStringNode);
     FunctionSignatureX toStringSignature = new FunctionSignatureX(
         type: new ResolutionFunctionType(toString, stringType));
     toString.functionSignature = toStringSignature;
     enumClass.addMember(toString, reporter);
 
     enumClass.enumValues = enumValues;
   }
 }