cleanup TokenType var names

pkg/front_end/lib/src/fasta/parser/parser.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.parser.parser;
 
 import '../fasta_codes.dart'
     show
         FastaCode,
         FastaMessage,
@@ skipping 275 matching lines @@
     return token;
   }
 
   Token parseTopLevelDeclaration(Token token) {
     token = _parseTopLevelDeclaration(token);
     listener.endTopLevelDeclaration(token);
     return token;
   }
 
   Token _parseTopLevelDeclaration(Token token) {
-    if (identical(token.info, TokenType.SCRIPT_TAG)) {
+    if (identical(token.type, TokenType.SCRIPT_TAG)) {
       return parseScript(token);
     }
     token = parseMetadataStar(token);
     final String value = token.stringValue;
     if ((identical(value, 'abstract') && optional('class', token.next)) ||
         identical(value, 'class')) {
       return parseClassOrNamedMixinApplication(token);
     } else if (identical(value, 'enum')) {
       return parseEnum(token);
     } else if (identical(value, 'typedef')) {
@@ skipping 2424 matching lines @@
     token = parseExpressionWithoutCascade(token);
     listener.handleConditionalExpression(question, colon);
     return token;
   }
 
   Token parsePrecedenceExpression(
       Token token, int precedence, bool allowCascades) {
     assert(precedence >= 1);
     assert(precedence <= POSTFIX_PRECEDENCE);
     token = parseUnaryExpression(token, allowCascades);
-    TokenType info = token.info;
-    int tokenLevel = info.precedence;
+    TokenType type = token.type;
+    int tokenLevel = type.precedence;
     for (int level = tokenLevel; level >= precedence; --level) {
       while (identical(tokenLevel, level)) {
         Token operator = token;
         if (identical(tokenLevel, CASCADE_PRECEDENCE)) {
           if (!allowCascades) {
             return token;
           }
           token = parseCascadeExpression(token);
         } else if (identical(tokenLevel, ASSIGNMENT_PRECEDENCE)) {
           // Right associative, so we recurse at the same precedence
           // level.
           listener.beginExpression(token.next);
           token = parsePrecedenceExpression(token.next, level, allowCascades);
           listener.handleAssignmentExpression(operator);
         } else if (identical(tokenLevel, POSTFIX_PRECEDENCE)) {
-          if (identical(info, TokenType.PERIOD) ||
-              identical(info, TokenType.QUESTION_PERIOD)) {
+          if (identical(type, TokenType.PERIOD) ||
+              identical(type, TokenType.QUESTION_PERIOD)) {
             // Left associative, so we recurse at the next higher precedence
             // level. However, POSTFIX_PRECEDENCE is the highest level, so we
             // should just call [parseUnaryExpression] directly. However, a
             // unary expression isn't legal after a period, so we call
             // [parsePrimary] instead.
             token = parsePrimary(
                 token.next, IdentifierContext.expressionContinuation);
             listener.handleBinaryExpression(operator);
-          } else if ((identical(info, TokenType.OPEN_PAREN)) ||
-              (identical(info, TokenType.OPEN_SQUARE_BRACKET))) {
+          } else if ((identical(type, TokenType.OPEN_PAREN)) ||
+              (identical(type, TokenType.OPEN_SQUARE_BRACKET))) {
             token = parseArgumentOrIndexStar(token);
-          } else if ((identical(info, TokenType.PLUS_PLUS)) ||
-              (identical(info, TokenType.MINUS_MINUS))) {
+          } else if ((identical(type, TokenType.PLUS_PLUS)) ||
+              (identical(type, TokenType.MINUS_MINUS))) {
             listener.handleUnaryPostfixAssignmentExpression(token);
             token = token.next;
           } else {
             token = reportUnexpectedToken(token).next;
           }
-        } else if (identical(info, TokenType.IS)) {
+        } else if (identical(type, TokenType.IS)) {
           token = parseIsOperatorRest(token);
-        } else if (identical(info, TokenType.AS)) {
+        } else if (identical(type, TokenType.AS)) {
           token = parseAsOperatorRest(token);
-        } else if (identical(info, TokenType.QUESTION)) {
+        } else if (identical(type, TokenType.QUESTION)) {
           token = parseConditionalExpressionRest(token);
         } else {
           // Left associative, so we recurse at the next higher
           // precedence level.
           listener.beginExpression(token.next);
           token =
               parsePrecedenceExpression(token.next, level + 1, allowCascades);
           listener.handleBinaryExpression(operator);
         }
-        info = token.info;
-        tokenLevel = info.precedence;
+        type = token.type;
+        tokenLevel = type.precedence;
         if (level == EQUALITY_PRECEDENCE || level == RELATIONAL_PRECEDENCE) {
           // We don't allow (a == b == c) or (a < b < c).
           // Continue the outer loop if we have matched one equality or
           // relational operator.
           break;
         }
       }
     }
     return token;
   }
@@ skipping 15 matching lines @@
     do {
       mark = token;
       if (optional('.', token)) {
         Token period = token;
         token = parseSend(token.next, IdentifierContext.expressionContinuation);
         listener.handleBinaryExpression(period);
       }
       token = parseArgumentOrIndexStar(token);
     } while (!identical(mark, token));
 
-    if (identical(token.info.precedence, ASSIGNMENT_PRECEDENCE)) {
+    if (identical(token.type.precedence, ASSIGNMENT_PRECEDENCE)) {
       Token assignment = token;
       token = parseExpressionWithoutCascade(token.next);
       listener.handleAssignmentExpression(assignment);
     }
     listener.endCascade();
     return token;
   }
 
   Token parseUnaryExpression(Token token, bool allowCascades) {
     String value = token.stringValue;
@@ skipping 1077 matching lines @@
     return reportUnrecoverableError(
         token, () => code.format(uri, token.charOffset, string));
   }
 }
 
 typedef FastaMessage NoArgument(Uri uri, int charOffset);
 
 typedef FastaMessage TokenArgument(Uri uri, int charOffset, Token token);
 
 typedef FastaMessage StringArgument(Uri uri, int charOffset, String string);