Remove DartString from constants.

pkg/compiler/lib/src/constants/values.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 dart2js.constants.values;
 
 import '../common.dart';
 import '../common_elements.dart';
 import '../elements/entities.dart';
 import '../elements/types.dart';
-import '../tree/dartstring.dart';
 import '../util/util.dart' show Hashing;
 
 enum ConstantValueKind {
   FUNCTION,
   NULL,
   INT,
   DOUBLE,
   BOOL,
   STRING,
   LIST,
@@ skipping 97 matching lines @@
 
   bool get isFunction => true;
 
   bool operator ==(var other) {
     if (other is! FunctionConstantValue) return false;
     return identical(other.element, element);
   }
 
   List<ConstantValue> getDependencies() => const <ConstantValue>[];
 
-  DartString toDartString() {
-    return new DartString.literal(element.name);
-  }
-
   DartType getType(CommonElements types) => type;
 
   int get hashCode => (17 * element.hashCode) & 0x7fffffff;
 
   accept(ConstantValueVisitor visitor, arg) => visitor.visitFunction(this, arg);
 
   ConstantValueKind get kind => ConstantValueKind.FUNCTION;
 
   String toDartText() {
     if (element.enclosingClass != null) {
@@ skipping 20 matching lines @@
     PrimitiveConstantValue otherPrimitive = other;
     // We use == instead of 'identical' so that DartStrings compare correctly.
     return primitiveValue == otherPrimitive.primitiveValue;
   }
 
   int get hashCode => throw new UnsupportedError('PrimitiveConstant.hashCode');
 
   // Primitive constants don't have dependencies.
   List<ConstantValue> getDependencies() => const <ConstantValue>[];
 
-  DartString toDartString();
+  /// Returns the constant value as its string representation.
+  String toDartString() => primitiveValue.toString();
 
   /// This value in Dart syntax.
   String toDartText() => primitiveValue.toString();
 }
 
 class NullConstantValue extends PrimitiveConstantValue {
   /** The value a Dart null is compiled to in JavaScript. */
   static const String JsNull = "null";
 
   const factory NullConstantValue() = NullConstantValue._internal;
 
   const NullConstantValue._internal();
 
   bool get isNull => true;
 
   get primitiveValue => null;
 
   DartType getType(CommonElements types) => types.nullType;
 
   // The magic constant has no meaning. It is just a random value.
   int get hashCode => 785965825;
 
-  DartString toDartString() => const LiteralDartString("null");
-
   accept(ConstantValueVisitor visitor, arg) => visitor.visitNull(this, arg);
 
   ConstantValueKind get kind => ConstantValueKind.NULL;
 
   String toStructuredText() => 'NullConstant';
 }
 
 abstract class NumConstantValue extends PrimitiveConstantValue {
   const NumConstantValue();
 
@@ skipping 59 matching lines @@
   // The is [:!IntConstant:] check at the beginning of the function makes sure
   // that we compare only equal to integer constants.
   bool operator ==(var other) {
     if (other is! IntConstantValue) return false;
     IntConstantValue otherInt = other;
     return primitiveValue == otherInt.primitiveValue;
   }
 
   int get hashCode => primitiveValue & Hashing.SMI_MASK;
 
-  DartString toDartString() {
-    return new DartString.literal(primitiveValue.toString());
-  }
-
   accept(ConstantValueVisitor visitor, arg) => visitor.visitInt(this, arg);
 
   ConstantValueKind get kind => ConstantValueKind.INT;
 
   String toStructuredText() => 'IntConstant(${toDartText()})';
 }
 
 class DoubleConstantValue extends NumConstantValue {
   final double primitiveValue;
 
@@ skipping 40 matching lines @@
       return primitiveValue.isNegative == otherValue.isNegative;
     } else if (primitiveValue.isNaN) {
       return otherValue.isNaN;
     } else {
       return primitiveValue == otherValue;
     }
   }
 
   int get hashCode => primitiveValue.hashCode;
 
-  DartString toDartString() {
-    return new DartString.literal(primitiveValue.toString());
-  }
-
   accept(ConstantValueVisitor visitor, arg) => visitor.visitDouble(this, arg);
 
   ConstantValueKind get kind => ConstantValueKind.DOUBLE;
 
   String toStructuredText() => 'DoubleConstant(${toDartText()})';
 }
 
 abstract class BoolConstantValue extends PrimitiveConstantValue {
   factory BoolConstantValue(value) {
     return value ? new TrueConstantValue() : new FalseConstantValue();
@@ skipping 23 matching lines @@
 
   bool get primitiveValue => true;
 
   FalseConstantValue negate() => new FalseConstantValue();
 
   bool operator ==(var other) => identical(this, other);
 
   // The magic constant is just a random value. It does not have any
   // significance.
   int get hashCode => 499;
-
-  DartString toDartString() => const LiteralDartString("true");
 }
 
 class FalseConstantValue extends BoolConstantValue {
   factory FalseConstantValue() => const FalseConstantValue._internal();
 
   const FalseConstantValue._internal() : super._internal();
 
   bool get isFalse => true;
 
   bool get primitiveValue => false;
 
   TrueConstantValue negate() => new TrueConstantValue();
 
   bool operator ==(var other) => identical(this, other);
 
   // The magic constant is just a random value. It does not have any
   // significance.
   int get hashCode => 536555975;
-
-  DartString toDartString() => const LiteralDartString("false");
 }
 
 class StringConstantValue extends PrimitiveConstantValue {
-  final DartString primitiveValue;
+  final String primitiveValue;
 
   final int hashCode;
 
   // TODO(floitsch): cache StringConstants.
-  // TODO(floitsch): compute hashcode without calling toString() on the
-  // DartString.
-  StringConstantValue(DartString value)
+  StringConstantValue(String value)
       : this.primitiveValue = value,
-        this.hashCode = value.slowToString().hashCode;
-
-  StringConstantValue.fromString(String value)
-      : this(new DartString.literal(value));
+        this.hashCode = value.hashCode;
 
   bool get isString => true;
 
   DartType getType(CommonElements types) => types.stringType;
 
   bool operator ==(var other) {
     if (identical(this, other)) return true;
     if (other is! StringConstantValue) return false;
     StringConstantValue otherString = other;
     return hashCode == otherString.hashCode &&
         primitiveValue == otherString.primitiveValue;
   }
 
-  DartString toDartString() => primitiveValue;
+  String toDartString() => primitiveValue;

[Siggi Cherem (dart-lang), 2017/05/08 22:24:04]

we could also get rid of the 'toDartString' entirely, and replace the evaluator
logic to say:

`'${primitiveConstantValue.primitiveValue}'` 

wdyt? Mainly that would be to not get confused with the "DartString" type in the
future when we see `toDartString`.

[Johnni Winther, 2017/05/09 08:18:13]

Done.

 
   int get length => primitiveValue.length;
 
   accept(ConstantValueVisitor visitor, arg) => visitor.visitString(this, arg);
 
   ConstantValueKind get kind => ConstantValueKind.STRING;
 
   // TODO(johnniwinther): Ensure correct escaping.
-  String toDartText() => '"${primitiveValue.slowToString()}"';
+  String toDartText() => '"${primitiveValue}"';
 
   String toStructuredText() => 'StringConstant(${toDartText()})';
 }
 
 abstract class ObjectConstantValue extends ConstantValue {
   final InterfaceType type;
 
   ObjectConstantValue(this.type);
 
   bool get isObject => true;
@@ skipping 361 matching lines @@
   DartType getType(CommonElements types) => types.dynamicType;
 
   ConstantValueKind get kind => ConstantValueKind.NON_CONSTANT;
 
   @override
   String toStructuredText() => 'NonConstant';
 
   @override
   String toDartText() => '>>non-constant<<';
 }