Remove DartString from constants.

pkg/compiler/lib/src/compile_time_constants.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.compile_time_constant_evaluator;
 
 import 'common/resolution.dart' show Resolution;
 import 'common/tasks.dart' show CompilerTask, Measurer;
 import 'common.dart';
 import 'compiler.dart' show Compiler;
@@ skipping 497 matching lines @@
         constantSystem.createMap(
             compiler.commonElements, type, keyValues, map.values.toList()));
   }
 
   AstConstant visitLiteralNull(LiteralNull node) {
     return new AstConstant(context, node, new NullConstantExpression(),
         constantSystem.createNull());
   }
 
   AstConstant visitLiteralString(LiteralString node) {
-    return new AstConstant(
-        context,
-        node,
-        new StringConstantExpression(node.dartString.slowToString()),
-        constantSystem.createString(node.dartString));
+    String text = node.dartString.slowToString();
+    return new AstConstant(context, node, new StringConstantExpression(text),
+        constantSystem.createString(text));
   }
 
   AstConstant visitStringJuxtaposition(StringJuxtaposition node) {
     AstConstant left = evaluate(node.first);
     AstConstant right = evaluate(node.second);
     if (left == null || left.isError) {
       return left;
     }
     if (right == null || right.isError) {
       return right;
     }
     StringConstantValue leftValue = left.value;
     StringConstantValue rightValue = right.value;
     return new AstConstant(
         context,
         node,
         new ConcatenateConstantExpression([left.expression, right.expression]),
-        constantSystem.createString(new DartString.concat(
-            leftValue.primitiveValue, rightValue.primitiveValue)));
+        constantSystem.createString(
+            leftValue.primitiveValue + rightValue.primitiveValue));
   }
 
   AstConstant visitStringInterpolation(StringInterpolation node) {
     List<ConstantExpression> subexpressions = <ConstantExpression>[];
     AstConstant initialString = evaluate(node.string);
     if (initialString == null || initialString.isError) {
       return initialString;
     }
     subexpressions.add(initialString.expression);
+    StringBuffer sb = new StringBuffer();
     StringConstantValue initialStringValue = initialString.value;
-    DartString accumulator = initialStringValue.primitiveValue;
+    sb.write(initialStringValue.primitiveValue);
     for (StringInterpolationPart part in node.parts) {
       AstConstant subexpression = evaluate(part.expression);
       if (subexpression == null || subexpression.isError) {
         return subexpression;
       }
       subexpressions.add(subexpression.expression);
       ConstantValue expression = subexpression.value;
-      DartString expressionString;
-      if (expression.isNum || expression.isBool || expression.isNull) {
+      if (expression.isPrimitive) {
         PrimitiveConstantValue primitive = expression;
-        expressionString =
-            new DartString.literal(primitive.primitiveValue.toString());
-      } else if (expression.isString) {
-        PrimitiveConstantValue primitive = expression;
-        expressionString = primitive.primitiveValue;
+        sb.write(primitive.primitiveValue);
       } else {
         // TODO(johnniwinther): Specialize message to indicated that the problem
         // is not constness but the types of the const expressions.
         return signalNotCompileTimeConstant(part.expression);
       }
-      accumulator = new DartString.concat(accumulator, expressionString);
       AstConstant partString = evaluate(part.string);
       if (partString == null) return null;
       subexpressions.add(partString.expression);
       StringConstantValue partStringValue = partString.value;
-      accumulator =
-          new DartString.concat(accumulator, partStringValue.primitiveValue);
+      sb.write(partStringValue.primitiveValue);
     }
     return new AstConstant(
         context,
         node,
         new ConcatenateConstantExpression(subexpressions),
-        constantSystem.createString(accumulator));
+        constantSystem.createString(sb.toString()));
   }
 
   AstConstant visitLiteralSymbol(LiteralSymbol node) {
     ResolutionInterfaceType type = commonElements.symbolImplementationType;
     String text = node.slowNameString;
     List<AstConstant> arguments = <AstConstant>[
       new AstConstant(context, node, new StringConstantExpression(text),
-          constantSystem.createString(new LiteralDartString(text)))
+          constantSystem.createString(text))
     ];
     ConstructorElement constructor =
         compiler.commonElements.symbolConstructorTarget;
     AstConstant constant = createConstructorInvocation(
         node, type, constructor, CallStructure.ONE_ARG,
         normalizedArguments: arguments);
     return new AstConstant(
         context, node, new SymbolConstantExpression(text), constant.value);
   }
 
@@ skipping 57 matching lines @@
         result = new AstConstant(
             context,
             send,
             new TypeConstantExpression(elementType, element.name),
             makeTypeConstant(elementType));
       } else if (send.receiver != null) {
         if (send.selector.asIdentifier().source == "length") {
           AstConstant left = evaluate(send.receiver);
           if (left != null && left.value.isString) {
             StringConstantValue stringConstantValue = left.value;
-            DartString string = stringConstantValue.primitiveValue;
+            String string = stringConstantValue.primitiveValue;
             IntConstantValue length = constantSystem.createInt(string.length);
             result = new AstConstant(context, send,
                 new StringLengthConstantExpression(left.expression), length);
           }
         }
         // Fall through to error handling.
       } else if (!Elements.isUnresolved(element) &&
           element.isVariable &&
           element.isConst) {
         LocalVariableElement local = element;
@@ skipping 354 matching lines @@
 
     if (constructor.isStringFromEnvironmentConstructor &&
         !(defaultValue.isNull || defaultValue.isString)) {
       ResolutionDartType type = defaultValue.getType(commonElements);
       return reportNotCompileTimeConstant(
           normalizedArguments[1].node,
           MessageKind.NOT_ASSIGNABLE,
           {'fromType': type, 'toType': commonElements.stringType});
     }
 
-    String name = firstArgument.primitiveValue.slowToString();
+    String name = firstArgument.primitiveValue;
     String value = compiler.fromEnvironment(name);
 
     AstConstant createEvaluatedConstant(ConstantValue value) {
       ConstantExpression expression;
       ConstantExpression name = concreteArguments[0].expression;
       ConstantExpression defaultValue;
       if (concreteArguments.length > 1) {
         defaultValue = concreteArguments[1].expression;
       }
       if (constructor.isIntFromEnvironmentConstructor) {
@@ skipping 19 matching lines @@
     } else if (constructor.isBoolFromEnvironmentConstructor) {
       if (value == 'true') {
         return createEvaluatedConstant(constantSystem.createBool(true));
       } else if (value == 'false') {
         return createEvaluatedConstant(constantSystem.createBool(false));
       } else {
         return createEvaluatedConstant(defaultValue);
       }
     } else {
       assert(constructor.isStringFromEnvironmentConstructor);
-      return createEvaluatedConstant(
-          constantSystem.createString(new DartString.literal(value)));
+      return createEvaluatedConstant(constantSystem.createString(value));
     }
   }
 
   static AstConstant makeConstructedConstant(
       Compiler compiler,
       ConstantCompilerBase handler,
       Element context,
       Node node,
       ResolutionInterfaceType type,
       ConstructorElement constructor,
@@ skipping 371 matching lines @@
   @override
   ConstantExpression getFieldConstant(FieldElement field) {
     return field.constant;
   }
 
   @override
   ConstantExpression getLocalConstant(LocalVariableElement local) {
     return local.constant;
   }
 }