Remove DartString from constants.

pkg/compiler/lib/src/ssa/builder_kernel.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.
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart';
 import '../common.dart';
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart';
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart';
 import '../constants/values.dart'
     show
         ConstantValue,
         InterceptorConstantValue,
         StringConstantValue,
         TypeConstantValue;
 import '../elements/elements.dart';
 import '../elements/entities.dart';
 import '../elements/resolution_types.dart';
 import '../io/source_information.dart';
 import '../js/js.dart' as js;
 import '../js_backend/backend.dart' show JavaScriptBackend;
 import '../kernel/kernel.dart';
 import '../native/native.dart' as native;
 import '../resolution/tree_elements.dart';
-import '../tree/dartstring.dart';
 import '../tree/nodes.dart' show Node;
 import '../types/masks.dart';
 import '../universe/selector.dart';
 import '../universe/side_effects.dart' show SideEffects;
 import '../universe/use.dart' show DynamicUse;
 import '../world.dart';
 import 'graph_builder.dart';
 import 'jump_handler.dart';
 import 'kernel_ast_adapter.dart';
 import 'kernel_string_builder.dart';
@@ skipping 663 matching lines @@
   }
 
   @override
   void defaultStatement(ir.Statement statement) {
     _trap('Unhandled ir.${statement.runtimeType}  $statement');
     pop();
   }
 
   void _trap(String message) {
     HInstruction nullValue = graph.addConstantNull(closedWorld);
-    HInstruction errorMessage =
-        graph.addConstantString(new DartString.literal(message), closedWorld);
+    HInstruction errorMessage = graph.addConstantString(message, closedWorld);
     HInstruction trap = new HForeignCode(js.js.parseForeignJS("#.#"),
         commonMasks.dynamicType, <HInstruction>[nullValue, errorMessage]);
     trap.sideEffects
       ..setAllSideEffects()
       ..setDependsOnSomething();
     push(trap);
   }
 
   /// Returns the current source element. This is used by the type builder.
   ///
@@ skipping 21 matching lines @@
     }
     if (target is ir.FunctionDeclaration) {
       return callMethodOfClosureClass();
     }
     Element element = astAdapter.getElement(target);
     return element;
   }
 
   @override
   void visitCheckLibraryIsLoaded(ir.CheckLibraryIsLoaded checkLoad) {
-    HInstruction prefixConstant = graph.addConstantString(
-        new DartString.literal(checkLoad.import.name), closedWorld);
+    HInstruction prefixConstant =
+        graph.addConstantString(checkLoad.import.name, closedWorld);
     var prefixElement = astAdapter.getElement(checkLoad.import);
     HInstruction uriConstant = graph.addConstantString(
-        new DartString.literal(prefixElement.deferredImport.uri.toString()),
-        closedWorld);
+        prefixElement.deferredImport.uri.toString(), closedWorld);
     _pushStaticInvocation(astAdapter.checkDeferredIsLoaded,
         [prefixConstant, uriConstant], astAdapter.checkDeferredIsLoadedType);
   }
 
   @override
   void visitLoadLibrary(ir.LoadLibrary loadLibrary) {
     // TODO(efortuna): Source information!
     push(new HInvokeStatic(
         commonElements.loadLibraryWrapper,
-        [
-          graph.addConstantString(
-              new DartString.literal(loadLibrary.import.name), closedWorld)
-        ],
+        [graph.addConstantString(loadLibrary.import.name, closedWorld)],
         commonMasks.nonNullType,
         targetCanThrow: false));
   }
 
   @override
   void visitBlock(ir.Block block) {
     assert(!isAborted());
     for (ir.Statement statement in block.statements) {
       statement.accept(this);
       if (!isReachable) {
@@ skipping 554 matching lines @@
           HTypeConversion.CAST_TYPE_CHECK);
       if (converted != expressionInstruction) {
         add(converted);
       }
       stack.add(converted);
     }
   }
 
   void generateError(
       ir.Node node, ir.Procedure procedure, String message, TypeMask typeMask) {
-    HInstruction errorMessage =
-        graph.addConstantString(new DartString.literal(message), closedWorld);
+    HInstruction errorMessage = graph.addConstantString(message, closedWorld);
     // TODO(sra): Associate source info from [node].
     _pushStaticInvocation(procedure, [errorMessage], typeMask);
   }
 
   void generateTypeError(ir.Node node, String message) {
     generateError(node, astAdapter.throwTypeError, message,
         astAdapter.throwTypeErrorType);
   }
 
   @override
@@ skipping 468 matching lines @@
     stack.add(graph.addConstantDouble(doubleLiteral.value, closedWorld));
   }
 
   @override
   void visitBoolLiteral(ir.BoolLiteral boolLiteral) {
     stack.add(graph.addConstantBool(boolLiteral.value, closedWorld));
   }
 
   @override
   void visitStringLiteral(ir.StringLiteral stringLiteral) {
-    stack.add(graph.addConstantString(
-        new DartString.literal(stringLiteral.value), closedWorld));
+    stack.add(graph.addConstantString(stringLiteral.value, closedWorld));
   }
 
   @override
   void visitSymbolLiteral(ir.SymbolLiteral symbolLiteral) {
     stack.add(graph.addConstant(
         astAdapter.getConstantForSymbol(symbolLiteral), closedWorld));
     registry?.registerConstSymbol(symbolLiteral.value);
   }
 
   @override
@@ skipping 526 matching lines @@
       reporter.reportErrorMessage(
           astAdapter.getNode(argument), MessageKind.GENERIC, {
         'text': "Error: Expected String constant as ${adjective}argument "
             "to '$methodName'."
       });
       return null;
     }
 
     HConstant hConstant = instruction;
     StringConstantValue stringConstant = hConstant.constant;
-    return stringConstant.primitiveValue.slowToString();
+    return stringConstant.primitiveValue;
   }
 
   void handleForeignJsCurrentIsolateContext(ir.StaticInvocation invocation) {
     if (_unexpectedForeignArguments(invocation, 0, 0)) {
       // Result expected on stack.
       stack.add(graph.addConstantNull(closedWorld));
       return;
     }
 
     if (!backendUsage.isIsolateInUse) {
@@ skipping 485 matching lines @@
         _containingClass(noSuchMethod) != astAdapter.objectClass) {
       // Register the call as dynamic if [noSuchMethod] on the super
       // class is _not_ the default implementation from [Object] (it might be
       // overridden in the super class, but it might have a different number of
       // arguments), in case the [noSuchMethod] implementation calls
       // [JSInvocationMirror._invokeOn].
       // TODO(johnniwinther): Register this more precisely.
       registry?.registerDynamicUse(new DynamicUse(selector, null));
     }
 
-    ConstantValue nameConstant =
-        constantSystem.createString(new DartString.literal(publicName));
+    ConstantValue nameConstant = constantSystem.createString(publicName);
 
     js.Name internalName = namer.invocationName(selector);
 
     var argumentsInstruction =
         new HLiteralList(arguments, commonMasks.extendableArrayType);
     add(argumentsInstruction);
 
     var argumentNames = new List<HInstruction>();
     for (String argumentName in selector.namedArguments) {
       ConstantValue argumentNameConstant =
-          constantSystem.createString(new DartString.literal(argumentName));
+          constantSystem.createString(argumentName);
       argumentNames.add(graph.addConstant(argumentNameConstant, closedWorld));
     }
     var argumentNamesInstruction =
         new HLiteralList(argumentNames, commonMasks.extendableArrayType);
     add(argumentNamesInstruction);
 
     ConstantValue kindConstant =
         constantSystem.createInt(selector.invocationMirrorKind);
 
     _pushStaticInvocation(
@@ skipping 506 matching lines @@
     enterBlock.setBlockFlow(
         new HTryBlockInformation(
             kernelBuilder.wrapStatementGraph(bodyGraph),
             exception,
             kernelBuilder.wrapStatementGraph(catchGraph),
             kernelBuilder.wrapStatementGraph(finallyGraph)),
         exitBlock);
     kernelBuilder.inTryStatement = previouslyInTryStatement;
   }
 }