Remove DartString from constants.

pkg/compiler/lib/src/ssa/builder.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';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 1452 matching lines @@
           <HInstruction>[idConstant, nameConstant], commonMasks.dynamicType));
     }
   }
 
   void assertIsSubtype(ast.Node node, ResolutionDartType subtype,
       ResolutionDartType supertype, String message) {
     HInstruction subtypeInstruction = typeBuilder.analyzeTypeArgument(
         localsHandler.substInContext(subtype), sourceElement);
     HInstruction supertypeInstruction = typeBuilder.analyzeTypeArgument(
         localsHandler.substInContext(supertype), sourceElement);
-    HInstruction messageInstruction = graph.addConstantString(
-        new ast.DartString.literal(message), closedWorld);
+    HInstruction messageInstruction =
+        graph.addConstantString(message, closedWorld);
     MethodElement element = commonElements.assertIsSubtype;
     var inputs = <HInstruction>[
       subtypeInstruction,
       supertypeInstruction,
       messageInstruction
     ];
     HInstruction assertIsSubtype =
         new HInvokeStatic(element, inputs, subtypeInstruction.instructionType);
     registry?.registerTypeVariableBoundsSubtypeCheck(subtype, supertype);
     add(assertIsSubtype);
@@ skipping 1328 matching lines @@
     HInstruction globalNameHNode = pop();
     if (!globalNameHNode.isConstantString()) {
       reporter.reportErrorMessage(arguments[1], MessageKind.GENERIC, {
         'text': 'Error: Expected String as second argument '
             'to JS_EMBEDDED_GLOBAL.'
       });
       return;
     }
     HConstant hConstant = globalNameHNode;
     StringConstantValue constant = hConstant.constant;
-    String globalName = constant.primitiveValue.slowToString();
+    String globalName = constant.primitiveValue;
     js.Template expr = js.js.expressionTemplateYielding(
         emitter.generateEmbeddedGlobalAccess(globalName));
     native.NativeBehavior nativeBehavior = elements.getNativeData(node);
     assert(invariant(node, nativeBehavior != null,
         message: "No NativeBehavior for $node"));
     TypeMask ssaType =
         TypeMaskFactory.fromNativeBehavior(nativeBehavior, closedWorld);
     push(new HForeignCode(expr, ssaType, const [],
         nativeBehavior: nativeBehavior));
   }
@@ skipping 141 matching lines @@
     }
   }
 
   generateDeferredLoaderGet(ast.Send node, FunctionElement deferredLoader,
       SourceInformation sourceInformation) {
     // Until now we only handle these as getters.
     invariant(node, deferredLoader.isDeferredLoaderGetter);
     FunctionEntity loadFunction = commonElements.loadLibraryWrapper;
     PrefixElement prefixElement = deferredLoader.enclosingElement;
     String loadId = deferredLoadTask.getImportDeferName(node, prefixElement);
-    var inputs = [
-      graph.addConstantString(new ast.DartString.literal(loadId), closedWorld)
-    ];
+    var inputs = [graph.addConstantString(loadId, closedWorld)];
     push(new HInvokeStatic(loadFunction, inputs, commonMasks.nonNullType,
         targetCanThrow: false)
       ..sourceInformation = sourceInformation);
   }
 
   generateSuperNoSuchMethodSend(
       ast.Send node, Selector selector, List<HInstruction> arguments) {
     String name = selector.name;
 
     ClassElement cls = currentNonClosureClass;
     MethodElement element = cls.lookupSuperMember(Identifiers.noSuchMethod_);
     if (!Selectors.noSuchMethod_.signatureApplies(element)) {
       ClassElement objectClass = commonElements.objectClass;
       element = objectClass.lookupMember(Identifiers.noSuchMethod_);
     }
     if (backendUsage.isInvokeOnUsed && !element.enclosingClass.isObject) {
       // Register the call as dynamic if [noSuchMethod] on the super
       // class is _not_ the default implementation from [Object], in
       // case the [noSuchMethod] implementation calls
       // [JSInvocationMirror._invokeOn].
       // TODO(johnniwinther): Register this more precisely.
       registry?.registerDynamicUse(new DynamicUse(selector, null));
     }
     String publicName = name;
     if (selector.isSetter) publicName += '=';
 
-    ConstantValue nameConstant =
-        constantSystem.createString(new ast.DartString.literal(publicName));
+    ConstantValue nameConstant = constantSystem.createString(publicName);
 
     js.Name internalName = namer.invocationName(selector);
 
     MethodElement createInvocationMirror =
         commonElements.createInvocationMirror;
     var argumentsInstruction = buildLiteralList(arguments);
     add(argumentsInstruction);
 
     var argumentNames = new List<HInstruction>();
     for (String argumentName in selector.namedArguments) {
       ConstantValue argumentNameConstant =
-          constantSystem.createString(new ast.DartString.literal(argumentName));
+          constantSystem.createString(argumentName);
       argumentNames.add(graph.addConstant(argumentNameConstant, closedWorld));
     }
     var argumentNamesInstruction = buildLiteralList(argumentNames);
     add(argumentNamesInstruction);
 
     ConstantValue kindConstant =
         constantSystem.createInt(selector.invocationMirrorKind);
 
     pushInvokeStatic(
         null,
@@ skipping 636 matching lines @@
       // resolved (a warning has been issued).
       handleInvalidStaticInvoke(node, element);
     } else {
       // TODO(ahe): Do something like [generateWrongArgumentCountError].
       stack.add(graph.addConstantNull(closedWorld));
     }
     return;
   }
 
   HConstant addConstantString(String string) {
-    ast.DartString dartString = new ast.DartString.literal(string);
-    return graph.addConstantString(dartString, closedWorld);
+    return graph.addConstantString(string, closedWorld);
   }
 
   HConstant addConstantStringFromName(js.Name name) {
     return graph.addConstantStringFromName(name, closedWorld);
   }
 
   visitClassTypeLiteralGet(ast.Send node, ConstantExpression constant, _) {
     generateConstantTypeLiteral(node);
   }
 
@@ skipping 114 matching lines @@
     MethodElement helper = commonElements.throwAbstractClassInstantiationError;
     generateError(node, message, helper);
   }
 
   void generateThrowNoSuchMethod(ast.Node diagnosticNode, String methodName,
       {Link<ast.Node> argumentNodes,
       List<HInstruction> argumentValues,
       List<String> existingArguments,
       SourceInformation sourceInformation}) {
     MethodElement helper = commonElements.throwNoSuchMethod;
-    ConstantValue receiverConstant =
-        constantSystem.createString(new ast.DartString.empty());
+    ConstantValue receiverConstant = constantSystem.createString('');
     HInstruction receiver = graph.addConstant(receiverConstant, closedWorld);
-    ast.DartString dartString = new ast.DartString.literal(methodName);
-    ConstantValue nameConstant = constantSystem.createString(dartString);
+    ConstantValue nameConstant = constantSystem.createString(methodName);
     HInstruction name = graph.addConstant(nameConstant, closedWorld);
     if (argumentValues == null) {
       argumentValues = <HInstruction>[];
       argumentNodes.forEach((argumentNode) {
         visit(argumentNode);
         HInstruction value = pop();
         argumentValues.add(value);
       });
     }
     HInstruction arguments = buildLiteralList(argumentValues);
     add(arguments);
     HInstruction existingNamesList;
     if (existingArguments != null) {
       List<HInstruction> existingNames = <HInstruction>[];
       for (String name in existingArguments) {
-        HInstruction nameConstant = graph.addConstantString(
-            new ast.DartString.literal(name), closedWorld);
+        HInstruction nameConstant = graph.addConstantString(name, closedWorld);
         existingNames.add(nameConstant);
       }
       existingNamesList = buildLiteralList(existingNames);
       add(existingNamesList);
     } else {
       existingNamesList = graph.addConstantNull(closedWorld);
     }
     pushInvokeStatic(
         diagnosticNode, helper, [receiver, name, arguments, existingNamesList],
         sourceInformation: sourceInformation);
@@ skipping 42 matching lines @@
         generateRuntimeError(node.send, message.toString());
       }
     } else if (Elements.isMalformed(element)) {
       // TODO(ahe): Do something like [generateWrongArgumentCountError].
       stack.add(graph.addConstantNull(closedWorld));
     } else if (node.isConst) {
       stack.add(addConstant(node));
       if (isSymbolConstructor) {
         ConstructedConstantValue symbol = getConstantForNode(node);
         StringConstantValue stringConstant = symbol.fields.values.single;
-        String nameString = stringConstant.toDartString().slowToString();
+        String nameString = stringConstant.primitiveValue;
         registry?.registerConstSymbol(nameString);
       }
     } else {
       handleNewSend(node);
     }
   }
 
   @override
   void errorNonConstantConstructorInvoke(
       ast.NewExpression node,
@@ skipping 1013 matching lines @@
 
   void visitLiteralDouble(ast.LiteralDouble node) {
     stack.add(graph.addConstantDouble(node.value, closedWorld));
   }
 
   void visitLiteralBool(ast.LiteralBool node) {
     stack.add(graph.addConstantBool(node.value, closedWorld));
   }
 
   void visitLiteralString(ast.LiteralString node) {
-    stack.add(graph.addConstantString(node.dartString, closedWorld));
+    stack.add(
+        graph.addConstantString(node.dartString.slowToString(), closedWorld));
   }
 
   void visitLiteralSymbol(ast.LiteralSymbol node) {
     stack.add(addConstant(node));
     registry?.registerConstSymbol(node.slowNameString);
   }
 
   void visitStringJuxtaposition(ast.StringJuxtaposition node) {
     if (!node.isInterpolation) {
       // This is a simple string with no interpolations.
-      stack.add(graph.addConstantString(node.dartString, closedWorld));
+      stack.add(
+          graph.addConstantString(node.dartString.slowToString(), closedWorld));
       return;
     }
     StringBuilderVisitor stringBuilder = new StringBuilderVisitor(this, node);
     stringBuilder.visit(node);
     stack.add(stringBuilder.result);
   }
 
   void visitLiteralNull(ast.LiteralNull node) {
     stack.add(graph.addConstantNull(closedWorld));
   }
@@ skipping 1783 matching lines @@
       this.oldReturnLocal,
       this.oldReturnType,
       this.oldResolvedAst,
       this.oldStack,
       this.oldLocalsHandler,
       this.inTryStatement,
       this.allFunctionsCalledOnce,
       this.oldElementInferenceResults)
       : super(function);
 }