rename fasta.Token.value --> lexeme

pkg/compiler/lib/src/tree/nodes.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.
 
 import 'dart:collection' show IterableMixin;
 
 import '../common.dart';
 import '../elements/elements.dart' show MetadataAnnotation;
 import '../resolution/secret_tree_element.dart'
     show NullTreeElementMixin, StoredTreeElementMixin;
@@ skipping 1073 matching lines @@
 
   visitChildren(Visitor visitor) {}
 
   visitChildren1(Visitor1 visitor, arg) {}
 
   Token getBeginToken() => asyncToken;
 
   Token getEndToken() => starToken != null ? starToken : asyncToken;
 
   /// Is `true` if this modifier is either `async` or `async*`.
-  bool get isAsynchronous => asyncToken.value == 'async';
+  bool get isAsynchronous => asyncToken.lexeme == 'async';
 
   /// Is `true` if this modifier is either `sync*` or `async*`.
   bool get isYielding => starToken != null;
 }
 
 class FunctionExpression extends Expression with StoredTreeElementMixin {
   final Node name;
   final NodeList typeVariables;
 
   /**
@@ skipping 106 matching lines @@
   LiteralInt(Token token, DecodeErrorHandler handler) : super(token, handler);
 
   LiteralInt asLiteralInt() => this;
 
   int get value {
     try {
       Token valueToken = token;
       if (identical(valueToken.kind, Tokens.PLUS_TOKEN)) {
         valueToken = valueToken.next;
       }
-      return int.parse(valueToken.value);
+      return int.parse(valueToken.lexeme);
     } on FormatException catch (ex) {
       (this.handler)(token, ex);
     }
   }
 
   accept(Visitor visitor) => visitor.visitLiteralInt(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitLiteralInt(this, arg);
 }
 
 class LiteralDouble extends Literal<double> {
   LiteralDouble(Token token, DecodeErrorHandler handler)
       : super(token, handler);
 
   LiteralDouble asLiteralDouble() => this;
 
   double get value {
     try {
       Token valueToken = token;
       if (identical(valueToken.kind, Tokens.PLUS_TOKEN)) {
         valueToken = valueToken.next;
       }
-      return double.parse(valueToken.value);
+      return double.parse(valueToken.lexeme);
     } on FormatException catch (ex) {
       (this.handler)(token, ex);
     }
   }
 
   accept(Visitor visitor) => visitor.visitLiteralDouble(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitLiteralDouble(this, arg);
 }
 
 class LiteralBool extends Literal<bool> {
   LiteralBool(Token token, DecodeErrorHandler handler) : super(token, handler);
 
   LiteralBool asLiteralBool() => this;
 
   bool get value {
     if (identical(token.stringValue, 'true')) return true;
     if (identical(token.stringValue, 'false')) return false;
-    (this.handler)(token, "not a bool ${token.value}");
+    (this.handler)(token, "not a bool ${token.lexeme}");
     throw false;
   }
 
   accept(Visitor visitor) => visitor.visitLiteralBool(this);
 
   accept1(Visitor1 visitor, arg) => visitor.visitLiteralBool(this, arg);
 }
 
 class StringQuoting {
   /// Cache of common quotings.
@@ skipping 152 matching lines @@
   String get slowNameString {
     Unparser unparser = new Unparser();
     unparser.unparseNodeListOfIdentifiers(identifiers);
     return unparser.result;
   }
 }
 
 class Identifier extends Expression with StoredTreeElementMixin {
   final Token token;
 
-  String get source => token.value;
+  String get source => token.lexeme;
 
   Identifier(Token this.token);
 
   bool isThis() => identical(source, 'this');
 
   bool isSuper() => identical(source, 'super');
 
   Identifier asIdentifier() => this;
 
   accept(Visitor visitor) => visitor.visitIdentifier(this);
@@ skipping 1770 matching lines @@
   get metadata => null;
   get type => null;
 
   // Typedef.
   get isGeneralizedTypeAlias => null;
   get templateParameters => null;
   get typeParameters => null;
   get formals => null;
   get typedefKeyword => null;
 }