rename fasta.Token.value --> lexeme

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 'keyword.dart' show Keyword;
 
 import 'precedence.dart' show BAD_INPUT_INFO, EOF_INFO, PrecedenceInfo;
 
@@ skipping 38 matching lines @@
    * 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.
    */
   PrecedenceInfo get info;
 
   /**
    * The string represented by this token, a substring of the source code.
    *
-   * For [StringToken]s the [value] includes the quotes, explicit escapes, etc.
+   * For [StringToken]s the [lexeme] includes the quotes, explicit escapes, etc.
    */
-  String get value;
+  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 [PrecedenceInfo] 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 [value] instead. The string literal
+   * 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;
 
   /**
@@ skipping 11 matching lines @@
    * see implementation in [KeywordToken].
    */
   bool isIdentifier();
 
   /**
    * 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 [value] for the text actually parsed by the token.
+   * 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 == BAD_INPUT_INFO) {
       // 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 value.length;
+      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;
 }
 
 /**
  * A [SymbolToken] represents the symbol in its precedence info.
  * Also used for end of file with EOF_INFO.
  */
 class SymbolToken extends Token {
   final PrecedenceInfo info;
 
   SymbolToken(this.info, int charOffset) : super(charOffset);
 
-  String get value => info.value;
+  String get lexeme => info.value;
 
   String get stringValue => info.value;
 
   bool isIdentifier() => false;
 
-  String toString() => "SymbolToken($value)";
+  String toString() => "SymbolToken($lexeme)";
 
   bool get isEof => info == EOF_INFO;
 }
 
 /**
  * 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 bracked in case
  * it can be identified during scanning.
  */
 class BeginGroupToken extends SymbolToken {
   Token endGroup;
 
   BeginGroupToken(PrecedenceInfo info, int charOffset)
       : super(info, charOffset);
 }
 
 /**
  * A keyword token.
  */
 class KeywordToken extends Token {
   final Keyword keyword;
 
   KeywordToken(this.keyword, int charOffset) : super(charOffset);
 
   PrecedenceInfo get info => keyword.info;
 
-  String get value => keyword.syntax;
+  String get lexeme => keyword.syntax;
 
   String get stringValue => keyword.syntax;
 
   bool isIdentifier() => keyword.isPseudo || keyword.isBuiltIn;
 
-  String toString() => "KeywordToken($value)";
+  String toString() => "KeywordToken($lexeme)";
 }
 
 /**
  * A String-valued token. Represents identifiers, string literals,
  * number literals, comments, and error tokens, using the corresponding
  * precedence info.
  */
 class StringToken extends Token {
   /**
    * The length threshold above which substring tokens are computed lazily.
@@ skipping 45 matching lines @@
       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);
     }
   }
 
-  String get value {
+  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;
       if (data is String) {
         valueOrLazySubstring = canonicalizedString(
             data, start, end, valueOrLazySubstring.boolValue);
       } else {
         valueOrLazySubstring =
             decodeUtf8(data, start, end, valueOrLazySubstring.boolValue);
       }
       return valueOrLazySubstring;
     }
   }
 
   /// See [Token.stringValue] for an explanation.
   String get stringValue => null;
 
   bool isIdentifier() => identical(kind, IDENTIFIER_TOKEN);
 
-  String toString() => "StringToken($value)";
+  String toString() => "StringToken($lexeme)";
 
   static final StringCanonicalizer canonicalizer = new StringCanonicalizer();
 
   static String canonicalizedString(
       String s, int start, int end, bool canonicalize) {
     if (!canonicalize) return s;
     return canonicalizer.canonicalize(s, start, end, false);
   }
 
   static String decodeUtf8(List<int> data, int start, int end, bool asciiOnly) {
@@ skipping 90 matching lines @@
       identical(value, "<=") ||
       identical(value, "<") ||
       identical(value, "&") ||
       identical(value, "^") ||
       identical(value, "|");
 }
 
 bool isTernaryOperator(String value) => identical(value, "[]=");
 
 bool isMinusOperator(String value) => identical(value, "-");