rename fasta.Token.value --> lexeme

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 '../scanner.dart' show ErrorToken;
 
 import '../scanner/recover.dart' show closeBraceFor, skipToEof;
 
@@ skipping 2672 matching lines @@
 
   Token parseParenthesizedExpressionOrFunctionLiteral(Token token) {
     BeginGroupToken beginGroup = token;
     // TODO(eernst): Check for NPE as described in issue 26252.
     Token nextToken = beginGroup.endGroup.next;
     int kind = nextToken.kind;
     if (mayParseFunctionExpressions &&
         (identical(kind, FUNCTION_TOKEN) ||
             identical(kind, OPEN_CURLY_BRACKET_TOKEN) ||
             (identical(kind, KEYWORD_TOKEN) &&
-                (nextToken.value == 'async' || nextToken.value == 'sync')))) {
+                (nextToken.lexeme == 'async' || nextToken.lexeme == 'sync')))) {
       listener.handleNoTypeVariables(token);
       return parseUnnamedFunction(token);
     } else {
       bool old = mayParseFunctionExpressions;
       mayParseFunctionExpressions = true;
       token = parseParenthesizedExpression(token);
       mayParseFunctionExpressions = old;
       return token;
     }
   }
@@ skipping 98 matching lines @@
   /// been parsed, or `listener.handleNoTypeArguments(..)` has been executed.
   Token parseLiteralFunctionSuffix(Token token) {
     assert(optional('(', token));
     BeginGroupToken beginGroup = token;
     if (beginGroup.endGroup != null) {
       Token nextToken = beginGroup.endGroup.next;
       int kind = nextToken.kind;
       if (identical(kind, FUNCTION_TOKEN) ||
           identical(kind, OPEN_CURLY_BRACKET_TOKEN) ||
           (identical(kind, KEYWORD_TOKEN) &&
-              (nextToken.value == 'async' || nextToken.value == 'sync'))) {
+              (nextToken.lexeme == 'async' || nextToken.lexeme == 'sync'))) {
         return parseUnnamedFunction(token);
       }
       // Fall through.
     }
     reportUnrecoverableError(token, ErrorKind.UnexpectedToken);
     return null;
   }
 
   /// genericListLiteral | genericMapLiteral | genericFunctionLiteral.
   ///
@@ skipping 699 matching lines @@
   }
 
   /// Don't call this method. Should only be used as a last resort when there
   /// is no feasible way to recover from a parser error.
   Token reportUnrecoverableError(Token token, ErrorKind kind, [Map arguments]) {
     Token next;
     if (token is ErrorToken) {
       next = reportErrorToken(token, false);
     } else {
       arguments ??= {};
-      arguments.putIfAbsent("actual", () => token.value);
+      arguments.putIfAbsent("actual", () => token.lexeme);
       next = listener.handleUnrecoverableError(token, kind, arguments)?.next;
     }
     return next ?? skipToEof(token);
   }
 
   void reportRecoverableError(Token token, ErrorKind kind, [Map arguments]) {
     if (token is ErrorToken) {
       reportErrorToken(token, true);
     } else {
       arguments ??= {};
@@ skipping 15 matching lines @@
           hex = "$padding$hex";
         }
         arguments = {'characterHex': hex};
         break;
 
       case ErrorKind.UnterminatedString:
         arguments = {'quote': token.start};
         break;
 
       case ErrorKind.UnmatchedToken:
-        String begin = token.begin.value;
+        String begin = token.begin.lexeme;
         String end = closeBraceFor(begin);
         arguments = {'begin': begin, 'end': end};
         break;
 
       case ErrorKind.Unspecified:
         arguments = {"text": token.assertionMessage};
         break;
 
       default:
         break;
     }
     if (isRecoverable) {
       listener.handleRecoverableError(token, kind, arguments);
       return null;
     } else {
       return listener.handleUnrecoverableError(token, kind, arguments)?.next;
     }
   }
 }