cleanup TokenType var names

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

 // Copyright (c) 2011, 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.token;
 
 import '../../scanner/token.dart' as analyzer;
 import '../../scanner/token.dart' show TokenType;
 
 import 'token_constants.dart' show IDENTIFIER_TOKEN;
@@ skipping 35 matching lines @@
 
   @override
   analyzer.CommentToken get precedingComments => precedingCommentTokens;
 
   @override
   void set precedingComments(analyzer.CommentToken token) {
     precedingCommentTokens = token;
   }
 
   /**
-   * The precedence info for this token. [info] determines the kind and the
-   * precedence level of this token.
-   *
-   * Defined as getter to save a field in the [KeywordToken] subclass.
-   */
-  TokenType get info;
-
-  /**
    * The string represented by this token, a substring of the source code.
    *
    * For [StringToken]s the [lexeme] includes the quotes, explicit escapes, etc.
    */
   String get lexeme;
 
   /**
    * For symbol and keyword tokens, returns the string value represented by this
    * token. For [StringToken]s this method returns [:null:].
    *
    * For [SymbolToken]s and [KeywordToken]s, the string value is a compile-time
    * constant originating in the [TokenType] or in the [Keyword] instance.
    * This allows testing for keywords and symbols using [:identical:], e.g.,
    * [:identical('class', token.value):].
    *
    * Note that returning [:null:] for string tokens is important to identify
    * symbols and keywords, we cannot use [lexeme] instead. The string literal
    *   "$a($b"
    * produces ..., SymbolToken($), StringToken(a), StringToken((), ...
    *
    * After parsing the identifier 'a', the parser tests for a function
    * declaration using [:identical(next.stringValue, '('):], which (rightfully)
    * returns false because stringValue returns [:null:].
    */
   String get stringValue;
 
   /**
-   * The kind enum of this token as determined by its [info].
+   * The kind enum of this token as determined by its [type].
    */
-  int get kind => info.kind;
+  int get kind => type.kind;
 
   /**
    * The precedence level for this token.
    */
-  int get precedence => info.precedence;
+  int get precedence => type.precedence;
 
   /**
    * True if this token is an identifier. Some keywords allowed as identifiers,
    * see implementation in [KeywordToken].
    */
   bool get isIdentifier;
 
   bool get isPseudo => false;
 
   /**
    * Returns a textual representation of this token to be used for debugging
    * purposes. The resulting string might contain information about the
    * structure of the token, for example 'StringToken(foo)' for the identifier
    * token 'foo'.
    *
    * Use [lexeme] for the text actually parsed by the token.
    */
   String toString();
 
   /**
    * The number of characters parsed by this token.
    */
   int get charCount {
-    if (info == analyzer.TokenType.BAD_INPUT) {
+    if (type == analyzer.TokenType.BAD_INPUT) {
       // This is a token that wraps around an error message. Return 1
       // instead of the size of the length of the error message.
       return 1;
     } else {
       return lexeme.length;
     }
   }
 
   /// The character offset of the end of this token within the source text.
   int get charEnd => charOffset + charCount;
 
   bool get isEof => false;
 
   bool get isBuiltInIdentifier => false;
 
   @override
-  bool get isOperator => info.isOperator;
+  bool get isOperator => type.isOperator;
 
   @override
-  bool get isUserDefinableOperator => info.isUserDefinableOperator;
-
-  @override
-  analyzer.TokenType get type => info;
+  bool get isUserDefinableOperator => type.isUserDefinableOperator;
 
   @override
   int get offset => charOffset;
 
   @override
   set offset(int newOffset) {
     charOffset = newOffset;
   }
 
   @override
@@ skipping 75 matching lines @@
 
   @override
   Object value() => lexeme;
 }
 
 /**
  * A [SymbolToken] represents the symbol in its precedence info.
  * Also used for end of file with EOF_INFO.
  */
 class SymbolToken extends Token {
-  final TokenType info;
+  final TokenType type;
 
-  SymbolToken(this.info, int charOffset) : super(charOffset);
+  SymbolToken(this.type, int charOffset) : super(charOffset);
 
   factory SymbolToken.eof(int charOffset) {
     var eof = new SyntheticSymbolToken(analyzer.TokenType.EOF, charOffset);
     // EOF points to itself so there's always infinite look-ahead.
     eof.previousToken = eof;
     eof.next = eof;
     return eof;
   }
 
   @override
-  String get lexeme => info.value;
+  String get lexeme => type.value;
 
   @override
-  String get stringValue => info.value;
+  String get stringValue => type.value;
 
   @override
   bool get isIdentifier => false;
 
   @override
   String toString() => "SymbolToken(${isEof ? '-eof-' : lexeme})";
 
   @override
-  bool get isEof => info == analyzer.TokenType.EOF;
+  bool get isEof => type == analyzer.TokenType.EOF;
 
   @override
   Token copyWithoutComments() => isEof
       ? new SymbolToken.eof(charOffset)
-      : new SymbolToken(info, charOffset);
+      : new SymbolToken(type, charOffset);
 }
 
 /**
  * A [SyntheticSymbolToken] represents the symbol in its precedence info
  * which does not exist in the original source.
  * For example, if the scanner finds '(' missing a ')'
  * then it will insert an synthetic ')'.
  */
 class SyntheticSymbolToken extends SymbolToken {
-  SyntheticSymbolToken(TokenType info, int charOffset)
-      : super(info, charOffset);
+  SyntheticSymbolToken(TokenType type, int charOffset)
+      : super(type, charOffset);
 
   @override
   int get charCount => 0;
 
   @override
   bool get isSynthetic => true;
 
   @override
   Token copyWithoutComments() => isEof
       ? new SymbolToken.eof(charOffset)
-      : new SyntheticSymbolToken(info, charOffset);
+      : new SyntheticSymbolToken(type, charOffset);
 }
 
 /**
  * A [BeginGroupToken] represents a symbol that may be the beginning of
  * a pair of brackets, i.e., ( { [ < or ${
  * The [endGroup] token points to the matching closing bracket in case
  * it can be identified during scanning.
  */
 class BeginGroupToken extends SymbolToken
     implements analyzer.BeginTokenWithComment {
   Token endGroup;
 
-  BeginGroupToken(TokenType info, int charOffset) : super(info, charOffset);
+  BeginGroupToken(TokenType type, int charOffset) : super(type, charOffset);
 
   @override
   analyzer.Token get endToken => endGroup;
 
   @override
   void set endToken(analyzer.Token token) {
     endGroup = token;
   }
 
   @override
-  Token copyWithoutComments() => new BeginGroupToken(info, charOffset);
+  Token copyWithoutComments() => new BeginGroupToken(type, charOffset);
 }
 
 /**
  * A keyword token.
  */
 class KeywordToken extends Token implements analyzer.KeywordTokenWithComment {
   final analyzer.Keyword keyword;
 
   KeywordToken(this.keyword, int charOffset) : super(charOffset);
 
@@ skipping 54 matching lines @@
    *
    * For string tokens that are substrings of the program source, the actual
    * substring extraction is performed lazily. This is beneficial because
    * not all scanned code is actually used. For unused parts, the substrings
    * are never computed and allocated.
    */
   static const int LAZY_THRESHOLD = 4;
 
   var /* String | LazySubtring */ valueOrLazySubstring;
 
-  final TokenType info;
+  final TokenType type;
 
   /**
    * Creates a non-lazy string token. If [canonicalize] is true, the string
    * is canonicalized before the token is created.
    */
-  StringToken.fromString(this.info, String value, int charOffset,
+  StringToken.fromString(this.type, String value, int charOffset,
       {bool canonicalize: false})
       : valueOrLazySubstring =
             canonicalizedString(value, 0, value.length, canonicalize),
         super(charOffset);
 
   /**
    * Creates a lazy string token. If [canonicalize] is true, the string
    * is canonicalized before the token is created.
    */
   StringToken.fromSubstring(
-      this.info, String data, int start, int end, int charOffset,
+      this.type, String data, int start, int end, int charOffset,
       {bool canonicalize: false})
       : super(charOffset) {
     int length = end - start;
     if (length <= LAZY_THRESHOLD) {
       valueOrLazySubstring =
           canonicalizedString(data, start, end, canonicalize);
     } else {
       valueOrLazySubstring =
           new LazySubstring(data, start, length, canonicalize);
     }
   }
 
   /**
    * Creates a lazy string token. If [asciiOnly] is false, the byte array
    * is passed through a UTF-8 decoder.
    */
-  StringToken.fromUtf8Bytes(this.info, List<int> data, int start, int end,
+  StringToken.fromUtf8Bytes(this.type, List<int> data, int start, int end,
       bool asciiOnly, int charOffset)
       : super(charOffset) {
     int length = end - start;
     if (length <= LAZY_THRESHOLD) {
       valueOrLazySubstring = decodeUtf8(data, start, end, asciiOnly);
     } else {
       valueOrLazySubstring = new LazySubstring(data, start, length, asciiOnly);
     }
   }
 
-  StringToken._(this.info, this.valueOrLazySubstring, int charOffset)
+  StringToken._(this.type, this.valueOrLazySubstring, int charOffset)
       : super(charOffset);
 
   String get lexeme {
     if (valueOrLazySubstring is String) {
       return valueOrLazySubstring;
     } else {
       assert(valueOrLazySubstring is LazySubstring);
       var data = valueOrLazySubstring.data;
       int start = valueOrLazySubstring.start;
       int end = start + valueOrLazySubstring.length;
@@ skipping 22 matching lines @@
     if (!canonicalize) return s;
     return canonicalizer.canonicalize(s, start, end, false);
   }
 
   static String decodeUtf8(List<int> data, int start, int end, bool asciiOnly) {
     return canonicalizer.canonicalize(data, start, end, asciiOnly);
   }
 
   @override
   Token copyWithoutComments() =>
-      new StringToken._(info, valueOrLazySubstring, charOffset);
+      new StringToken._(type, valueOrLazySubstring, charOffset);
 
   @override
   String value() => lexeme;
 }
 
 /**
  * A String-valued token that does not exist in the original source.
  */
 class SyntheticStringToken extends StringToken
     implements analyzer.SyntheticStringToken {
-  SyntheticStringToken(TokenType info, String value, int offset)
-      : super._(info, value, offset);
+  SyntheticStringToken(TokenType type, String value, int offset)
+      : super._(type, value, offset);
 
   @override
   bool get isSynthetic => true;
 
   @override
   int get length => 0;
 
   @override
   Token copyWithoutComments() =>
-      new SyntheticStringToken(info, valueOrLazySubstring, offset);
+      new SyntheticStringToken(type, valueOrLazySubstring, offset);
 }
 
 class CommentToken extends StringToken implements analyzer.CommentToken {
   @override
   analyzer.TokenWithComment parent;
 
   /**
    * Creates a lazy comment token. If [canonicalize] is true, the string
    * is canonicalized before the token is created.
    */
   CommentToken.fromSubstring(
-      TokenType info, String data, int start, int end, int charOffset,
+      TokenType type, String data, int start, int end, int charOffset,
       {bool canonicalize: false})
-      : super.fromSubstring(info, data, start, end, charOffset,
+      : super.fromSubstring(type, data, start, end, charOffset,
             canonicalize: canonicalize);
 
   /**
    * Creates a non-lazy comment token.
    */
-  CommentToken.fromString(TokenType info, String lexeme, int charOffset)
-      : super.fromString(info, lexeme, charOffset);
+  CommentToken.fromString(TokenType type, String lexeme, int charOffset)
+      : super.fromString(type, lexeme, charOffset);
 
   /**
    * Creates a lazy string token. If [asciiOnly] is false, the byte array
    * is passed through a UTF-8 decoder.
    */
-  CommentToken.fromUtf8Bytes(TokenType info, List<int> data, int start, int end,
+  CommentToken.fromUtf8Bytes(TokenType type, List<int> data, int start, int end,
       bool asciiOnly, int charOffset)
-      : super.fromUtf8Bytes(info, data, start, end, asciiOnly, charOffset);
+      : super.fromUtf8Bytes(type, data, start, end, asciiOnly, charOffset);
 
-  CommentToken._(TokenType info, valueOrLazySubstring, int charOffset)
-      : super._(info, valueOrLazySubstring, charOffset);
+  CommentToken._(TokenType type, valueOrLazySubstring, int charOffset)
+      : super._(type, valueOrLazySubstring, charOffset);
 
   @override
   CommentToken copy() =>
-      new CommentToken._(info, valueOrLazySubstring, charOffset);
+      new CommentToken._(type, valueOrLazySubstring, charOffset);
 
   @override
   void remove() {
     if (previous != null) {
       previous.setNextWithoutSettingPrevious(next);
       next?.previous = previous;
     } else {
       assert(parent.precedingComments == this);
       parent.precedingComments = next as CommentToken;
     }
   }
 }
 
 class DartDocToken extends CommentToken
     implements analyzer.DocumentationCommentToken {
   /**
    * The references embedded within the documentation comment.
    * This list will be empty unless this is a documentation comment that has
    * references embedded within it.
    */
   final List<Token> references = <Token>[];
 
   /**
    * Creates a lazy comment token. If [canonicalize] is true, the string
    * is canonicalized before the token is created.
    */
   DartDocToken.fromSubstring(
-      TokenType info, String data, int start, int end, int charOffset,
+      TokenType type, String data, int start, int end, int charOffset,
       {bool canonicalize: false})
-      : super.fromSubstring(info, data, start, end, charOffset,
+      : super.fromSubstring(type, data, start, end, charOffset,
             canonicalize: canonicalize);
 
   /**
    * Creates a lazy string token. If [asciiOnly] is false, the byte array
    * is passed through a UTF-8 decoder.
    */
-  DartDocToken.fromUtf8Bytes(TokenType info, List<int> data, int start, int end,
+  DartDocToken.fromUtf8Bytes(TokenType type, List<int> data, int start, int end,
       bool asciiOnly, int charOffset)
-      : super.fromUtf8Bytes(info, data, start, end, asciiOnly, charOffset);
+      : super.fromUtf8Bytes(type, data, start, end, asciiOnly, charOffset);
 
-  DartDocToken._(TokenType info, valueOrLazySubstring, int charOffset)
-      : super._(info, valueOrLazySubstring, charOffset);
+  DartDocToken._(TokenType type, valueOrLazySubstring, int charOffset)
+      : super._(type, valueOrLazySubstring, charOffset);
 
   @override
   DartDocToken copy() {
     DartDocToken copy =
-        new DartDocToken._(info, valueOrLazySubstring, charOffset);
+        new DartDocToken._(type, valueOrLazySubstring, charOffset);
     references.forEach((ref) => copy.references.add(ref.copy()));
     return copy;
   }
 }
 
 /**
  * This class represents the necessary information to compute a substring
  * lazily. The substring can either originate from a string or from
  * a [:List<int>:] of UTF-8 bytes.
  */
@@ skipping 81 matching lines @@
       identical(value, "<=") ||
       identical(value, "<") ||
       identical(value, "&") ||
       identical(value, "^") ||
       identical(value, "|");
 }
 
 bool isTernaryOperator(String value) => identical(value, "[]=");
 
 bool isMinusOperator(String value) => identical(value, "-");