rename fasta.Token.value --> lexeme

pkg/front_end/lib/src/fasta/analyzer/ast_builder.dart

 // Copyright (c) 2016, 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.analyzer.ast_builder;
 
 import 'package:analyzer/analyzer.dart';
 import 'package:analyzer/dart/ast/ast_factory.dart' show AstFactory;
 import 'package:analyzer/dart/ast/standard_ast_factory.dart' as standard;
 import 'package:analyzer/dart/ast/token.dart' as analyzer show Token;
@@ skipping 91 matching lines @@
     push(ast.parenthesizedExpression(
         toAnalyzerToken(token), expression, toAnalyzerToken(token.endGroup)));
   }
 
   void handleStringPart(Token token) {
     debugEvent("StringPart");
     push(token);
   }
 
   void doStringPart(Token token) {
-    push(ast.simpleStringLiteral(toAnalyzerToken(token), token.value));
+    push(ast.simpleStringLiteral(toAnalyzerToken(token), token.lexeme));
   }
 
   void endLiteralString(int interpolationCount) {
     debugEvent("endLiteralString");
     if (interpolationCount == 0) {
       Token token = pop();
-      String value = unescapeString(token.value);
+      String value = unescapeString(token.lexeme);
       push(ast.simpleStringLiteral(toAnalyzerToken(token), value));
     } else {
       List parts = popList(1 + interpolationCount * 2);
       Token first = parts.first;
       Token last = parts.last;
-      Quote quote = analyzeQuote(first.value);
+      Quote quote = analyzeQuote(first.lexeme);
       List<InterpolationElement> elements = <InterpolationElement>[];
       elements.add(ast.interpolationString(
-          toAnalyzerToken(first), unescapeFirstStringPart(first.value, quote)));
+          toAnalyzerToken(first), unescapeFirstStringPart(first.lexeme, quote)));

[ahe, 2017/03/10 07:26:11]

Long line.

[danrubel, 2017/03/11 22:10:38]

Reformatted.

       for (int i = 1; i < parts.length - 1; i++) {
         var part = parts[i];
         if (part is Token) {
           elements
-              .add(ast.interpolationString(toAnalyzerToken(part), part.value));
+              .add(ast.interpolationString(toAnalyzerToken(part), part.lexeme));
         } else if (part is Expression) {
           elements.add(ast.interpolationExpression(null, part, null));
         } else {
           internalError(
               "Unexpected part in string interpolation: ${part.runtimeType}");
         }
       }
       elements.add(ast.interpolationString(
-          toAnalyzerToken(last), unescapeLastStringPart(last.value, quote)));
+          toAnalyzerToken(last), unescapeLastStringPart(last.lexeme, quote)));
       push(ast.stringInterpolation(elements));
     }
   }
 
   void handleScript(Token token) {
     debugEvent("Script");
     push(ast.scriptTag(toAnalyzerToken(token)));
   }
 
   void handleStringJuxtaposition(int literalCount) {
@@ skipping 26 matching lines @@
         push(identifier);
       }
     } else if (context == IdentifierContext.enumValueDeclaration) {
       // TODO(paulberry): analyzer's ASTs allow for enumerated values to have
       // metadata, but the spec doesn't permit it.
       List<Annotation> metadata;
       Comment comment = _toAnalyzerComment(token.precedingComments);
       push(ast.enumConstantDeclaration(comment, metadata, identifier));
     } else {
       if (context.isScopeReference) {
-        String name = token.value;
+        String name = token.lexeme;
         Builder builder = scope.lookup(name, token.charOffset, uri);
         if (builder != null) {
           Element element = elementStore[builder];
           assert(element != null);
           identifier.staticElement = element;
         }
       } else if (context == IdentifierContext.classDeclaration) {
         className = identifier.name;
       }
       push(identifier);
@@ skipping 125 matching lines @@
         ..operator = toAnalyzerToken(token);
       push(identifierOrInvoke);
     } else {
       internalError(
           "Unhandled property access: ${identifierOrInvoke.runtimeType}");
     }
   }
 
   void handleLiteralInt(Token token) {
     debugEvent("LiteralInt");
-    push(ast.integerLiteral(toAnalyzerToken(token), int.parse(token.value)));
+    push(ast.integerLiteral(toAnalyzerToken(token), int.parse(token.lexeme)));
   }
 
   void endExpressionFunctionBody(Token arrowToken, Token endToken) {
     debugEvent("ExpressionFunctionBody");
     Expression expression = pop();
     analyzer.Token star = pop();
     analyzer.Token asyncKeyword = pop();
     assert(star == null);
     push(ast.expressionFunctionBody(asyncKeyword, toAnalyzerToken(arrowToken),
         expression, toAnalyzerToken(endToken)));
@@ skipping 141 matching lines @@
 
   void handleLiteralBool(Token token) {
     debugEvent("LiteralBool");
     bool value = identical(token.stringValue, "true");
     assert(value || identical(token.stringValue, "false"));
     push(ast.booleanLiteral(toAnalyzerToken(token), value));
   }
 
   void handleLiteralDouble(Token token) {
     debugEvent("LiteralDouble");
-    push(ast.doubleLiteral(toAnalyzerToken(token), double.parse(token.value)));
+    push(ast.doubleLiteral(toAnalyzerToken(token), double.parse(token.lexeme)));
   }
 
   void handleLiteralNull(Token token) {
     debugEvent("LiteralNull");
     push(ast.nullLiteral(toAnalyzerToken(token)));
   }
 
   void handleLiteralMap(
       int count, Token beginToken, Token constKeyword, Token endToken) {
     debugEvent("LiteralMap");
@@ skipping 987 matching lines @@
   Token abstractKeyword;
   Token externalKeyword;
   Token finalConstOrVarKeyword;
   Token staticKeyword;
 
   _Modifiers(List<Token> modifierTokens) {
     // No need to check the order and uniqueness of the modifiers, or that
     // disallowed modifiers are not used; the parser should do that.
     // TODO(paulberry,ahe): implement the necessary logic in the parser.
     for (var token in modifierTokens) {
-      var s = token.value;
+      var s = token.lexeme;
       if (identical('abstract', s)) {
         abstractKeyword = token;
       } else if (identical('const', s)) {
         finalConstOrVarKeyword = token;
       } else if (identical('external', s)) {
         externalKeyword = token;
       } else if (identical('final', s)) {
         finalConstOrVarKeyword = token;
       } else if (identical('static', s)) {
         staticKeyword = token;
       } else if (identical('var', s)) {
         finalConstOrVarKeyword = token;
       } else {
         internalError('Unhandled modifier: $s');
       }
     }
   }
 }