rename fasta.Token.value --> lexeme

pkg/front_end/lib/src/fasta/kernel/body_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.body_builder;
 
 import '../parser/parser.dart' show FormalParameterType, optional;
 
 import '../parser/error_kind.dart' show ErrorKind;
 
@@ skipping 699 matching lines @@
   Builder computeSetter(
       Builder builder, Scope scope, String name, int charOffset) {
     if (builder.isSetter) return builder;
     if (builder.isGetter) return scope.lookupSetter(name, charOffset, uri);
     return builder.isField ? (builder.isFinal ? null : builder) : null;
   }
 
   @override
   void handleIdentifier(Token token, IdentifierContext context) {
     debugEvent("handleIdentifier");
-    String name = token.value;
+    String name = token.lexeme;
     if (isFirstIdentifier) {
       assert(!inInitializer ||
           this.scope == enclosingScope ||
           this.scope.parent == enclosingScope);
       // This deals with this kind of initializer: `C(a) : a = a;`
       Scope scope = inInitializer ? enclosingScope : this.scope;
       Builder builder = scope.lookup(name, token.charOffset, uri);
       push(builderToFirstExpression(builder, name, token.charOffset));
     } else {
       push(new Identifier(name)..fileOffset = token.charOffset);
@@ skipping 62 matching lines @@
   void handleStringPart(Token token) {
     debugEvent("StringPart");
     push(token);
   }
 
   @override
   void endLiteralString(int interpolationCount, Token endToken) {
     debugEvent("endLiteralString");
     if (interpolationCount == 0) {
       Token token = pop();
-      push(new StringLiteral(unescapeString(token.value)));
+      push(new StringLiteral(unescapeString(token.lexeme)));
     } 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<Expression> expressions = <Expression>[];
       expressions
-          .add(new StringLiteral(unescapeFirstStringPart(first.value, quote)));
+          .add(new StringLiteral(unescapeFirstStringPart(first.lexeme, quote)));
       for (int i = 1; i < parts.length - 1; i++) {
         var part = parts[i];
         if (part is Token) {
-          expressions.add(new StringLiteral(unescape(part.value, quote)));
+          expressions.add(new StringLiteral(unescape(part.lexeme, quote)));
         } else {
           expressions.add(toValue(part));
         }
       }
       expressions
-          .add(new StringLiteral(unescapeLastStringPart(last.value, quote)));
+          .add(new StringLiteral(unescapeLastStringPart(last.lexeme, quote)));
       push(new StringConcatenation(expressions)
         ..fileOffset = endToken.charOffset);
     }
   }
 
   @override
   void handleScript(Token token) {
     debugEvent("Script");
   }
 
@@ skipping 15 matching lines @@
           expressions.add(part);
         }
       }
     }
     push(new StringConcatenation(expressions ?? parts));
   }
 
   @override
   void handleLiteralInt(Token token) {
     debugEvent("LiteralInt");
-    push(new IntLiteral(int.parse(token.value)));
+    push(new IntLiteral(int.parse(token.lexeme)));
   }
 
   @override
   void endExpressionFunctionBody(Token arrowToken, Token endToken) {
     debugEvent("ExpressionFunctionBody");
     endReturnStatement(true, arrowToken, endToken);
   }
 
   @override
   void endReturnStatement(
@@ skipping 218 matching lines @@
   void handleLiteralBool(Token token) {
     debugEvent("LiteralBool");
     bool value = optional("true", token);
     assert(value || optional("false", token));
     push(new BoolLiteral(value));
   }
 
   @override
   void handleLiteralDouble(Token token) {
     debugEvent("LiteralDouble");
-    push(new DoubleLiteral(double.parse(token.value)));
+    push(new DoubleLiteral(double.parse(token.lexeme)));
   }
 
   @override
   void handleLiteralNull(Token token) {
     debugEvent("LiteralNull");
     push(new NullLiteral());
   }
 
   @override
   void handleLiteralMap(
@@ skipping 104 matching lines @@
         push(const DynamicType());
         addCompileTimeError(beginToken.charOffset,
             "Can't be used as a type: '${debugName(prefix, suffix)}'.");
         return;
       }
     }
     if (name is Identifier) {
       name = name.name;
     }
     if (name is BuilderAccessor) {
-      warning("'${beginToken.value}' isn't a type.", beginToken.charOffset);
+      warning("'${beginToken.lexeme}' isn't a type.", beginToken.charOffset);
       push(const DynamicType());
     } else if (name is UnresolvedIdentifier) {
       warning("'${name.name}' isn't a type.", beginToken.charOffset);
       push(const DynamicType());
     } else if (name is TypeVariableBuilder) {
       push(name.buildTypesWithBuiltArguments(library, arguments));
     } else if (name is TypeDeclarationBuilder) {
       push(name.buildTypesWithBuiltArguments(library, arguments));
     } else if (name is TypeBuilder) {
       push(name.build(library));
@@ skipping 268 matching lines @@
       } else {
         push(buildMethodInvocation(toValue(receiver), new Name(operator),
             new Arguments.empty(), token.charOffset));
       }
     }
   }
 
   Name incrementOperator(Token token) {
     if (optional("++", token)) return plusName;
     if (optional("--", token)) return minusName;
-    return internalError("Unknown increment operator: ${token.value}");
+    return internalError("Unknown increment operator: ${token.lexeme}");
   }
 
   @override
   void handleUnaryPrefixAssignmentExpression(Token token) {
     debugEvent("UnaryPrefixAssignmentExpression");
     var accessor = pop();
     if (accessor is BuilderAccessor) {
       push(accessor.buildPrefixIncrement(
           incrementOperator(token), token.charOffset));
     } else {
@@ skipping 44 matching lines @@
       var prefix = type[0];
       identifier = type[1];
       if (prefix is PrefixBuilder) {
         // TODO(ahe): Handle privacy in prefix.exports.
         type = builderToFirstExpression(
             prefix.exports[identifier.name], identifier.name, start.charOffset);
         identifier = null;
       } else if (prefix is ClassBuilder) {
         type = prefix;
       } else {
-        type = new Identifier(start.value)..fileOffset = start.charOffset;
+        type = new Identifier(start.lexeme)..fileOffset = start.charOffset;
       }
     }
     String name;
     if (identifier != null && suffix != null) {
       name = "${identifier.name}.${suffix.name}";
     } else if (identifier != null) {
       name = identifier.name;
     } else if (suffix != null) {
       name = suffix.name;
     } else {
@@ skipping 624 matching lines @@
 
   @override
   Token handleUnrecoverableError(Token token, ErrorKind kind, Map arguments) {
     if (isDartLibrary && kind == ErrorKind.ExpectedFunctionBody) {
       Token recover = skipNativeClause(token);
       if (recover != null) return recover;
     } else if (kind == ErrorKind.UnexpectedToken) {
       String expected = arguments["expected"];
       const List<String> trailing = const <String>[")", "}", ";", ","];
       if (trailing.contains(token.stringValue) && trailing.contains(expected)) {
-        arguments.putIfAbsent("actual", () => token.value);
+        arguments.putIfAbsent("actual", () => token.lexeme);
         handleRecoverableError(token, ErrorKind.ExpectedButGot, arguments);
         return newSyntheticToken(token);
       }
     }
     return super.handleUnrecoverableError(token, kind, arguments);
   }
 
   @override
   Expression buildCompileTimeError(error, [int charOffset = -1]) {
     addCompileTimeError(charOffset, error);
@@ skipping 490 matching lines @@
   } else if (node is PrefixBuilder) {
     return node.name;
   } else if (node is ThisAccessor) {
     return node.isSuper ? "super" : "this";
   } else if (node is BuilderAccessor) {
     return node.plainNameForRead;
   } else {
     return internalError("Unhandled: ${node.runtimeType}");
   }
 }