Move array and string related HType from const to a field in the backend.

sdk/lib/_internal/compiler/implementation/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.
 
 part of ssa;
 
 /**
  * A special element for the extra parameter taken by intercepted
  * methods. We need to override [Element.computeType] because our
  * optimizers may look at its declared type.
@@ skipping 55 matching lines @@
         if (element.isMember()) {
           String className = element.getEnclosingClass().name.slowToString();
           String memberName = element.name.slowToString();
           name = "$className.$memberName";
           if (element.isGenerativeConstructorBody()) {
             name = "$name (body)";
           }
         } else {
           name = "${element.name.slowToString()}";
         }
-        compiler.tracer.traceCompilation(name, work.compilationContext);
+        compiler.tracer.traceCompilation(
+            name, work.compilationContext, compiler);
         compiler.tracer.traceGraph('builder', graph);
       }
       return graph;
     });
   }
 
   HGraph compileConstructor(SsaBuilder builder, CodegenWorkItem work) {
     return builder.buildFactory(work.element);
   }
 }
@@ skipping 735 matching lines @@
 
   void generateContinue([LabelElement label]) {
     if (isContinueToSwitchCase(label)) {
       // Creates the special instructions 'label = i; continue l;' used in
       // switch statements with continue statements. See
       // [SsaBuilder.buildComplexSwitchStatement] for detail.
 
       assert(label != null);
       HInstruction value = builder.graph.addConstantInt(
           targetIndexMap[label.target],
-          builder.constantSystem);
+          builder.compiler);
       builder.localsHandler.updateLocal(target, value);
 
       assert(label.target.labels.contains(label));
       HInstruction continueInstruction = new HContinue(target);
       LocalsHandler locals = new LocalsHandler.from(builder.localsHandler);
       builder.close(continueInstruction);
       jumps.add(new JumpHandlerEntry(continueInstruction, locals));
     } else {
       super.generateContinue(label);
     }
@@ skipping 167 matching lines @@
     // If [functionElement] is `operator==` we explicitely add a null check at
     // the beginning of the method. This is to avoid having call sites do the
     // null check.
     if (name == const SourceString('==')) {
       if (!backend.operatorEqHandlesNullArgument(functionElement)) {
         handleIf(
             function,
             () {
               HParameterValue parameter = parameters.values.first;
               push(new HIdentity(
-                  parameter, graph.addConstantNull(constantSystem)));
+                  parameter, graph.addConstantNull(compiler)));
             },
             () {
               closeAndGotoExit(new HReturn(
-                  graph.addConstantBool(false, constantSystem)));
+                  graph.addConstantBool(false, compiler)));
             },
             null);
       }
     }
     function.body.accept(this);
     return closeFunction();
   }
 
   HGraph buildLazyInitializer(VariableElement variable) {
     SendSet node = variable.parseNode(compiler);
@@ skipping 151 matching lines @@
         newLocalsHandler.updateLocal(typeVariable.element, argument);
       });
     }
     assert(argumentIndex == compiledArguments.length);
 
     // TODO(kasperl): Bad smell. We shouldn't be constructing elements here.
     returnElement = new ElementX(const SourceString("result"),
                                  ElementKind.VARIABLE,
                                  function);
     newLocalsHandler.updateLocal(returnElement,
-                                 graph.addConstantNull(constantSystem));
+                                 graph.addConstantNull(compiler));
     elements = compiler.enqueuer.resolution.getCachedElements(function);
     assert(elements != null);
     returnType = signature.returnType;
     stack = <HInstruction>[];
     inliningStack.add(state);
     localsHandler = newLocalsHandler;
     return state;
   }
 
   void leaveInlinedMethod(InliningState state) {
@@ skipping 139 matching lines @@
           localsHandler.updateLocal(typeVariables.head.element,
               analyzeTypeArgument(argument, callNode));
           typeVariables = typeVariables.tail;
         });
         // If the supertype is a raw type, we need to set to null the
         // type variables.
         assert(typeVariables.isEmpty
                || superclass.typeVariables == typeVariables);
         while (!typeVariables.isEmpty) {
           localsHandler.updateLocal(typeVariables.head.element,
-              graph.addConstantNull(constantSystem));
+              graph.addConstantNull(compiler));
           typeVariables = typeVariables.tail;
         }
       }
 
       inlinedFrom(constructor, () {
         buildFieldInitializers(constructor.enclosingElement.implementation,
                                fieldValues);
       });
 
       int index = 0;
@@ skipping 126 matching lines @@
                               Map<Element, HInstruction> fieldValues) {
     assert(invariant(classElement, classElement.isImplementation));
     classElement.forEachInstanceField(
         (ClassElement enclosingClass, Element member) {
           compiler.withCurrentElement(member, () {
             TreeElements definitions = compiler.analyzeElement(member);
             Node node = member.parseNode(compiler);
             SendSet assignment = node.asSendSet();
             HInstruction value;
             if (assignment == null) {
-              value = graph.addConstantNull(constantSystem);
+              value = graph.addConstantNull(compiler);
             } else {
               Node right = assignment.arguments.head;
               TreeElements savedElements = elements;
               elements = definitions;
               // In case the field initializer uses closures, run the
               // closure to class mapper.
               compiler.closureToClassMapper.computeClosureToClassMapping(
                   member, node, elements);
               inlinedFrom(member, () => right.accept(this));
               elements = savedElements;
@@ skipping 166 matching lines @@
       //
       // foo([a = 42]) {
       //   var t1 = identical(a, sentinel);
       //   if (t1) a = 42;
       //   if (!t1) print('parameter passed ' + a);
       // }
 
       // Fetch the original default value of [element];
       Constant constant = compileVariable(element);
       HConstant defaultValue = constant == null
-          ? graph.addConstantNull(constantSystem)
-          : graph.addConstant(constant);
+          ? graph.addConstantNull(compiler)
+          : graph.addConstant(constant, compiler);
 
       // Emit the equality check with the sentinel.
-      HConstant sentinel = graph.addConstant(SentinelConstant.SENTINEL);
+      HConstant sentinel =
+          graph.addConstant(SentinelConstant.SENTINEL, compiler);
       HInstruction operand = parameters[element];
       check = new HIdentity(sentinel, operand);
       add(check);
 
       // If the check succeeds, we must update the parameter with the
       // default value.
       handleIf(element.parseNode(compiler),
                () => stack.add(check),
                () => localsHandler.updateLocal(element, defaultValue),
                null);
@@ skipping 541 matching lines @@
       Node initializer = node.initializer;
       if (initializer != null) {
         visit(initializer);
         if (initializer.asExpression() != null) {
           pop();
         }
       }
     }
     HInstruction buildCondition() {
       if (node.condition == null) {
-        return graph.addConstantBool(true, constantSystem);
+        return graph.addConstantBool(true, compiler);
       }
       visit(node.condition);
       return popBoolified();
     }
     void buildUpdate() {
       for (Expression expression in node.update) {
         visit(expression);
         assert(!isAborted());
         // The result of the update instruction isn't used, and can just
         // be dropped.
@@ skipping 240 matching lines @@
     visit(node.receiver);
     assert(!identical(op.token.kind, PLUS_TOKEN));
     HInstruction operand = pop();
 
     // See if we can constant-fold right away. This avoids rewrites later on.
     if (operand is HConstant) {
       UnaryOperation operation = constantSystem.lookupUnary(op.source);
       HConstant constant = operand;
       Constant folded = operation.fold(constant.constant);
       if (folded != null) {
-        stack.add(graph.addConstant(folded));
+        stack.add(graph.addConstant(folded, compiler));
         return;
       }
     }
 
     pushInvokeDynamic(node, elements.getSelector(node), [operand]);
   }
 
   void visitBinary(HInstruction left,
                    Operator op,
                    HInstruction right,
@@ skipping 47 matching lines @@
 
   void generateGetter(Send send, Element element) {
     if (Elements.isStaticOrTopLevelField(element)) {
       Constant value;
       if (element.isField() && !element.isAssignable()) {
         // A static final or const. Get its constant value and inline it if
         // the value can be compiled eagerly.
         value = compileVariable(element);
       }
       if (value != null) {
-        stack.add(graph.addConstant(value));
+        stack.add(graph.addConstant(value, compiler));
       } else if (element.isField() && isLazilyInitialized(element)) {
         HInstruction instruction = new HLazyStatic(element);
         instruction.instructionType =
             new HType.inferredTypeForElement(element, compiler);
         push(instruction);
       } else {
         if (element.isGetter()) {
           pushInvokeStatic(send, element, <HInstruction>[]);
         } else {
           // TODO(5346): Try to avoid the need for calling [declaration] before
@@ skipping 96 matching lines @@
                          HType type,
                          List<HInstruction> inputs) {
     return new HForeign(js.js.parseForeignJS(code), type, inputs);
   }
 
   HInstruction getRuntimeTypeInfo(HInstruction target) {
     pushInvokeStatic(null, backend.getGetRuntimeTypeInfo(), [target]);
     return pop();
   }
 
+  HLiteralList buildLiteralList(List<HInstruction> inputs) {
+    return new HLiteralList(inputs)..instructionType =
+        backend.extendableArrayType;
+  }
+
   // TODO(karlklose): change construction of the representations to be GVN'able
   // (dartbug.com/7182).
   HInstruction buildTypeArgumentRepresentations(DartType type) {
     // Compute the representation of the type arguments, including access
     // to the runtime type information for type variables as instructions.
     if (type.kind == TypeKind.TYPE_VARIABLE) {
-      return new HLiteralList(<HInstruction>[addTypeVariableReference(type)]);
+      return buildLiteralList(<HInstruction>[addTypeVariableReference(type)]);
     } else {
       assert(type.element.isClass());
       InterfaceType interface = type;
       List<HInstruction> inputs = <HInstruction>[];
       bool first = true;
       List<String> templates = <String>[];
       for (DartType argument in interface.typeArguments) {
         templates.add(rti.getTypeRepresentation(argument, (variable) {
           HInstruction runtimeType = addTypeVariableReference(variable);
           inputs.add(runtimeType);
         }));
       }
       String template = '[${templates.join(', ')}]';
       HInstruction representation =
-        createForeign(template, HType.READABLE_ARRAY, inputs);
+        createForeign(template, backend.readableArrayType, inputs);
       return representation;
     }
   }
 
   visitOperatorSend(node) {
     Operator op = node.selector;
     if (const SourceString("[]") == op.source) {
       visitDynamicSend(node);
     } else if (const SourceString("&&") == op.source ||
                const SourceString("||") == op.source) {
@@ skipping 58 matching lines @@
       ClassElement element = type.element;
       Element helper = backend.getCheckSubtype();
       HInstruction representations =
           buildTypeArgumentRepresentations(type);
       add(representations);
       String operator =
           backend.namer.operatorIs(backend.getImplementationClass(element));
       HInstruction isFieldName = addConstantString(node, operator);
       HInstruction asFieldName = compiler.world.hasAnySubtype(element)
           ? addConstantString(node, backend.namer.substitutionName(element))
-          : graph.addConstantNull(constantSystem);
+          : graph.addConstantNull(compiler);
       List<HInstruction> inputs = <HInstruction>[expression,
                                                  isFieldName,
                                                  representations,
                                                  asFieldName];
       pushInvokeStatic(node, helper, inputs, HType.BOOLEAN);
       HInstruction call = pop();
       return
           new HIs(type, <HInstruction>[expression, call], HIs.COMPOUND_CHECK);
     } else {
       return new HIs(type, <HInstruction>[expression], HIs.RAW_CHECK);
@@ skipping 38 matching lines @@
   HInstruction handleConstantForOptionalParameter(Element parameter) {
     Constant constant;
     Element element = parameter.enclosingElement;
     TreeElements calleeElements =
         compiler.enqueuer.resolution.getCachedElements(element);
     if (calleeElements.isParameterChecked(parameter)) {
       constant = SentinelConstant.SENTINEL;
     } else {
       constant = compileConstant(parameter);
     }
-    return graph.addConstant(constant);
+    return graph.addConstant(constant, compiler);
   }
 
   /**
    * Returns true if the arguments were compatible with the function signature.
    *
    * Invariant: [element] must be an implementation element.
    */
   bool addStaticSendArgumentsToList(Selector selector,
                                     Link<Node> arguments,
                                     FunctionElement element,
@@ skipping 262 matching lines @@
       compiler.enqueuer.codegen.registerSelectorUse(selector);
     }
     Constant nameConstant = constantSystem.createString(
         new DartString.literal(name.slowToString()), node);
 
     String internalName = backend.namer.invocationName(selector);
     Constant internalNameConstant =
         constantSystem.createString(new DartString.literal(internalName), node);
 
     Element createInvocationMirror = backend.getCreateInvocationMirror();
-    var argumentsInstruction = new HLiteralList(arguments);
+    var argumentsInstruction = buildLiteralList(arguments);
     add(argumentsInstruction);
 
     var argumentNames = new List<HInstruction>();
     for (SourceString argumentName in selector.namedArguments) {
       Constant argumentNameConstant =
           constantSystem.createString(new DartString.literal(
               argumentName.slowToString()), node);
-      argumentNames.add(graph.addConstant(argumentNameConstant));
+      argumentNames.add(graph.addConstant(argumentNameConstant, compiler));
     }
-    var argumentNamesInstruction = new HLiteralList(argumentNames);
+    var argumentNamesInstruction = buildLiteralList(argumentNames);
     add(argumentNamesInstruction);
 
     Constant kindConstant =
         constantSystem.createInt(selector.invocationMirrorKind);
 
     pushInvokeStatic(null,
                      createInvocationMirror,
-                     [graph.addConstant(nameConstant),
-                      graph.addConstant(internalNameConstant),
-                      graph.addConstant(kindConstant),
+                     [graph.addConstant(nameConstant, compiler),
+                      graph.addConstant(internalNameConstant, compiler),
+                      graph.addConstant(kindConstant, compiler),
                       argumentsInstruction,
                       argumentNamesInstruction],
                       HType.UNKNOWN);
 
     var inputs = <HInstruction>[pop()];
     push(buildInvokeSuper(compiler.noSuchMethodSelector, element, inputs));
   }
 
   visitSend(Send node) {
     Element element = elements[node];
@@ skipping 42 matching lines @@
    * them as an instance of the type we are testing against (if necessary), and
    * extract the type argument by the index of the variable in the list of type
    * variables for that class.
    */
   HInstruction readTypeVariable(ClassElement cls,
                                 TypeVariableElement variable) {
     assert(currentElement.isInstanceMember());
     int index = RuntimeTypes.getTypeVariableIndex(variable);
     String substitutionNameString = backend.namer.substitutionName(cls);
     HInstruction substitutionName = graph.addConstantString(
-        new LiteralDartString(substitutionNameString), null, constantSystem);
+        new LiteralDartString(substitutionNameString), null, compiler);
     HInstruction target = localsHandler.readThis();
     HInstruction substitution = createForeign('#[#]', HType.UNKNOWN,
         <HInstruction>[target, substitutionName]);
     add(substitution);
     pushInvokeStatic(null,
                      backend.getGetRuntimeTypeArgument(),
                      [target,
                       substitution,
-                      graph.addConstantInt(index, constantSystem)],
+                      graph.addConstantInt(index, compiler)],
                       HType.UNKNOWN);
     return pop();
   }
 
   /**
    * Helper to create an instruction that gets the value of a type variable.
    */
   HInstruction addTypeVariableReference(TypeVariableType type) {
     Element member = currentElement;
     bool isClosure = member.enclosingElement.isClosure();
@@ skipping 27 matching lines @@
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [argument] must not be malformed in checked mode.
    */
   HInstruction analyzeTypeArgument(DartType argument, Node currentNode) {
     assert(invariant(currentNode,
                      !compiler.enableTypeAssertions || !argument.isMalformed,
                      message: '$argument is malformed in checked mode'));
     if (argument == compiler.types.dynamicType || argument.isMalformed) {
       // Represent [dynamic] as [null].
-      return graph.addConstantNull(constantSystem);
+      return graph.addConstantNull(compiler);
     }
 
     List<HInstruction> inputs = <HInstruction>[];
 
     String template = rti.getTypeRepresentation(argument, (variable) {
       inputs.add(addTypeVariableReference(variable));
     });
 
-    HInstruction result = createForeign(template, HType.STRING, inputs);
+    HInstruction result = createForeign(template, backend.stringType, inputs);
     add(result);
     return result;
   }
 
   void handleListConstructor(InterfaceType type,
                              Node currentNode,
                              HInstruction newObject) {
     if (!backend.needsRti(type.element)) return;
     if (!type.isRaw) {
       List<HInstruction> inputs = <HInstruction>[];
       type.typeArguments.forEach((DartType argument) {
         inputs.add(analyzeTypeArgument(argument, currentNode));
       });
       callSetRuntimeTypeInfo(type.element, inputs, newObject);
     }
   }
 
   void callSetRuntimeTypeInfo(ClassElement element,
                               List<HInstruction> rtiInputs,
                               HInstruction newObject) {
     if (!backend.needsRti(element) || element.typeVariables.isEmpty) {
       return;
     }
 
-    HInstruction typeInfo = new HLiteralList(rtiInputs);
+    HInstruction typeInfo = buildLiteralList(rtiInputs);
     add(typeInfo);
 
     // Set the runtime type information on the object.
     Element typeInfoSetterElement = backend.getSetRuntimeTypeInfo();
     pushInvokeStatic(
         null,
         typeInfoSetterElement,
         <HInstruction>[newObject, typeInfo],
         HType.UNKNOWN);
     pop();
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [type] must not be malformed in checked mode.
    */
   handleNewSend(NewExpression node, InterfaceType type) {
     Send send = node.send;
     assert(invariant(send,
                      !compiler.enableTypeAssertions || !type.isMalformed,
                      message: '$type is malformed in checked mode'));
     bool isListConstructor = false;
     computeType(element) {
       Element originalElement = elements[send];
       if (Elements.isFixedListConstructorCall(
               originalElement, send, compiler)) {
         isListConstructor = true;
-        return HType.FIXED_ARRAY;
+        return backend.fixedArrayType;
       } else if (Elements.isGrowableListConstructorCall(
                     originalElement, send, compiler)) {
         isListConstructor = true;
-        return HType.EXTENDABLE_ARRAY;
+        return backend.extendableArrayType;
       } else if (element.isGenerativeConstructor()) {
         ClassElement cls = element.getEnclosingClass();
         return new HType.nonNullExact(cls.thisType, compiler);
       } else {
         return new HType.inferredTypeForElement(originalElement, compiler);
       }
     }
 
     Element constructor = elements[send];
     Selector selector = elements.getSelector(send);
@@ skipping 54 matching lines @@
     }
     if (backend.needsRti(cls)) {
       Link<DartType> typeVariable = cls.typeVariables;
       type.typeArguments.forEach((DartType argument) {
         inputs.add(analyzeTypeArgument(argument, send));
         typeVariable = typeVariable.tail;
       });
       // Also add null to non-provided type variables to call the
       // constructor with the right number of arguments.
       while (!typeVariable.isEmpty) {
-        inputs.add(graph.addConstantNull(constantSystem));
+        inputs.add(graph.addConstantNull(compiler));
         typeVariable = typeVariable.tail;
       }
     }
 
     if (constructor.isFactoryConstructor() && !type.typeArguments.isEmpty) {
       compiler.enqueuer.codegen.registerFactoryWithTypeArguments(elements);
     }
     HType elementType = computeType(constructor);
     pushInvokeStatic(node, constructor, inputs, elementType);
     HInstruction newInstance = stack.last;
@@ skipping 24 matching lines @@
       return;
     }
     if (element.isErroneous()) {
       generateThrowNoSuchMethod(node,
                                 getTargetName(element),
                                 argumentNodes: node.arguments);
       return;
     }
     if (identical(element, compiler.assertMethod)
         && !compiler.enableUserAssertions) {
-      stack.add(graph.addConstantNull(constantSystem));
+      stack.add(graph.addConstantNull(compiler));
       return;
     }
     compiler.ensure(!element.isGenerativeConstructor());
     if (element.isFunction()) {
       var inputs = <HInstruction>[];
       // TODO(5347): Try to avoid the need for calling [implementation] before
       // calling [addStaticSendArgumentsToList].
       bool succeeded = addStaticSendArgumentsToList(selector, node.arguments,
                                                     element.implementation,
                                                     inputs);
@@ skipping 13 matching lines @@
       List<HInstruction> inputs = <HInstruction>[pop()];
       addDynamicSendArgumentsToList(node, inputs);
       Selector closureSelector = new Selector.callClosureFrom(selector);
       pushWithPosition(new HInvokeClosure(closureSelector, inputs), node);
     }
   }
 
   HConstant addConstantString(Node node, String string) {
     DartString dartString = new DartString.literal(string);
     Constant constant = constantSystem.createString(dartString, node);
-    return graph.addConstant(constant);
+    return graph.addConstant(constant, compiler);
   }
 
   visitTypeReferenceSend(Send node) {
     Element element = elements[node];
     if (element.isClass() || element.isTypedef()) {
       // TODO(karlklose): add type representation
       ConstantHandler handler = compiler.constantHandler;
       Constant constant = handler.compileNodeWithDefinitions(node, elements);
-      stack.add(graph.addConstant(constant));
+      stack.add(graph.addConstant(constant, compiler));
     } else if (element.isTypeVariable()) {
       HInstruction value =
           addTypeVariableReference(element.computeType(compiler));
       pushInvokeStatic(node,
                        backend.getRuntimeTypeToString(),
                        [value],
-                       HType.STRING);
+                       backend.stringType);
       pushInvokeStatic(node,
                        backend.getCreateRuntimeType(),
                        [pop()]);
     } else {
       internalError('unexpected element kind $element', node: node);
     }
     if (node.isCall) {
       // This send is of the form 'e(...)', where e is resolved to a type
       // reference. We create a regular closure call on the result of the type
       // reference instead of creating a NoSuchMethodError to avoid pulling it
@@ skipping 32 matching lines @@
   }
 
   void generateThrowNoSuchMethod(Node diagnosticNode,
                                  String methodName,
                                  {Link<Node> argumentNodes,
                                   List<HInstruction> argumentValues,
                                   List<String> existingArguments}) {
     Element helper = backend.getThrowNoSuchMethod();
     Constant receiverConstant =
         constantSystem.createString(new DartString.empty(), diagnosticNode);
-    HInstruction receiver = graph.addConstant(receiverConstant);
+    HInstruction receiver = graph.addConstant(receiverConstant, compiler);
     DartString dartString = new DartString.literal(methodName);
     Constant nameConstant =
         constantSystem.createString(dartString, diagnosticNode);
-    HInstruction name = graph.addConstant(nameConstant);
+    HInstruction name = graph.addConstant(nameConstant, compiler);
     if (argumentValues == null) {
       argumentValues = <HInstruction>[];
       argumentNodes.forEach((argumentNode) {
         visit(argumentNode);
         HInstruction value = pop();
         argumentValues.add(value);
       });
     }
-    HInstruction arguments = new HLiteralList(argumentValues);
+    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 DartString.literal(name),
-                                    diagnosticNode, constantSystem);
+                                    diagnosticNode, compiler);
         existingNames.add(nameConstant);
       }
-      existingNamesList = new HLiteralList(existingNames);
+      existingNamesList = buildLiteralList(existingNames);
       add(existingNamesList);
     } else {
-      existingNamesList = graph.addConstantNull(constantSystem);
+      existingNamesList = graph.addConstantNull(compiler);
     }
     pushInvokeStatic(diagnosticNode,
                      helper,
                      [receiver, name, arguments, existingNamesList]);
   }
 
   /**
    * Generate code to throw a [NoSuchMethodError] exception for calling a
    * method with a wrong number of arguments or mismatching named optional
    * arguments.
@@ skipping 34 matching lines @@
                                   getTargetName(error, 'constructor'),
                                   argumentNodes: node.send.arguments);
       } else {
         Message message = error.messageKind.message(error.messageArguments);
         generateRuntimeError(node.send, message.toString());
       }
     } else if (node.isConst()) {
       // TODO(karlklose): add type representation
       ConstantHandler handler = compiler.constantHandler;
       Constant constant = handler.compileNodeWithDefinitions(node, elements);
-      stack.add(graph.addConstant(constant));
+      stack.add(graph.addConstant(constant, compiler));
       if (isSymbolConstructor) {
         ConstructedConstant symbol = constant;
         StringConstant stringConstant = symbol.fields.single;
         String nameString = stringConstant.toDartString().slowToString();
         compiler.enqueuer.codegen.registerConstSymbol(nameString, elements);
       }
     } else {
       DartType type = elements.getType(node);
       if (compiler.enableTypeAssertions && type.isMalformed) {
         String reasons = Types.fetchReasonsFromMalformedType(type);
@@ skipping 130 matching lines @@
         new HType.inferredReturnTypeForElement(element, compiler);
     instruction.sideEffects = compiler.world.getSideEffectsOfElement(element);
     return instruction;
   }
 
   void handleComplexOperatorSend(SendSet node,
                                  HInstruction receiver,
                                  Link<Node> arguments) {
     HInstruction rhs;
     if (node.isPrefix || node.isPostfix) {
-      rhs = graph.addConstantInt(1, constantSystem);
+      rhs = graph.addConstantInt(1, compiler);
     } else {
       visit(arguments.head);
       assert(arguments.tail.isEmpty);
       rhs = pop();
     }
     visitBinary(receiver, node.assignmentOperator, rhs,
                 elements.getOperatorSelectorInComplexSendSet(node), node);
   }
 
   visitSendSet(SendSet node) {
@@ skipping 130 matching lines @@
         generateNonInstanceSetter(node, element, value);
       }
       if (node.isPostfix) {
         pop();
         stack.add(getterInstruction);
       }
     }
   }
 
   void visitLiteralInt(LiteralInt node) {
-    stack.add(graph.addConstantInt(node.value, constantSystem));
+    stack.add(graph.addConstantInt(node.value, compiler));
   }
 
   void visitLiteralDouble(LiteralDouble node) {
-    stack.add(graph.addConstantDouble(node.value, constantSystem));
+    stack.add(graph.addConstantDouble(node.value, compiler));
   }
 
   void visitLiteralBool(LiteralBool node) {
-    stack.add(graph.addConstantBool(node.value, constantSystem));
+    stack.add(graph.addConstantBool(node.value, compiler));
   }
 
   void visitLiteralString(LiteralString node) {
-    stack.add(graph.addConstantString(node.dartString, node, constantSystem));
+    stack.add(graph.addConstantString(node.dartString, node, compiler));
   }
 
   void visitStringJuxtaposition(StringJuxtaposition node) {
     if (!node.isInterpolation) {
       // This is a simple string with no interpolations.
-      stack.add(graph.addConstantString(node.dartString, node, constantSystem));
+      stack.add(graph.addConstantString(node.dartString, node, compiler));
       return;
     }
     StringBuilderVisitor stringBuilder = new StringBuilderVisitor(this, node);
     stringBuilder.visit(node);
     stack.add(stringBuilder.result);
   }
 
   void visitLiteralNull(LiteralNull node) {
-    stack.add(graph.addConstantNull(constantSystem));
+    stack.add(graph.addConstantNull(compiler));
   }
 
   visitNodeList(NodeList node) {
     for (Link<Node> link = node.nodes; !link.isEmpty; link = link.tail) {
       if (isAborted()) {
         compiler.reportWarning(link.head, 'dead code');
       } else {
         visit(link.head);
       }
     }
@@ skipping 23 matching lines @@
     if (!inTryStatement) return;
     HBasicBlock block = close(new HExitTry());
     HBasicBlock newBlock = graph.addNewBlock();
     block.addSuccessor(newBlock);
     open(newBlock);
   }
 
   visitRethrow(Rethrow node) {
     HInstruction exception = rethrowableException;
     if (exception == null) {
-      exception = graph.addConstantNull(constantSystem);
+      exception = graph.addConstantNull(compiler);
       compiler.internalError(
           'rethrowableException should not be null', node: node);
     }
     handleInTryStatement();
     closeAndGotoExit(new HThrow(exception, isRethrow: true));
   }
 
   visitReturn(Return node) {
     if (identical(node.getBeginToken().stringValue, 'native')) {
       native.handleSsaNative(this, node.expression);
       return;
     }
     HInstruction value;
     if (node.isRedirectingFactoryBody) {
       // TODO(ahe): This is only for reflection, and it is not correct yet.
-      value = graph.addConstantNull(constantSystem);
+      value = graph.addConstantNull(compiler);
     } else if (node.expression == null) {
-      value = graph.addConstantNull(constantSystem);
+      value = graph.addConstantNull(compiler);
     } else {
       visit(node.expression);
       value = pop();
       value = potentiallyCheckType(value, returnType);
     }
 
     handleInTryStatement();
 
     if (!inliningStack.isEmpty) {
       localsHandler.updateLocal(returnElement, value);
@@ skipping 16 matching lines @@
                            node: node);
   }
 
   visitVariableDefinitions(VariableDefinitions node) {
     assert(isReachable);
     for (Link<Node> link = node.definitions.nodes;
          !link.isEmpty;
          link = link.tail) {
       Node definition = link.head;
       if (definition is Identifier) {
-        HInstruction initialValue = graph.addConstantNull(constantSystem);
+        HInstruction initialValue = graph.addConstantNull(compiler);
         localsHandler.updateLocal(elements[definition], initialValue);
       } else {
         assert(definition is SendSet);
         visitSendSet(definition);
         pop();  // Discard value.
       }
     }
   }
 
   visitLiteralList(LiteralList node) {
     if (node.isConst()) {
       ConstantHandler handler = compiler.constantHandler;
       Constant constant = handler.compileNodeWithDefinitions(node, elements);
-      stack.add(graph.addConstant(constant));
+      stack.add(graph.addConstant(constant, compiler));
       return;
     }
 
     List<HInstruction> inputs = <HInstruction>[];
     for (Link<Node> link = node.elements.nodes;
          !link.isEmpty;
          link = link.tail) {
       visit(link.head);
       inputs.add(pop());
     }
-    push(new HLiteralList(inputs));
+    push(buildLiteralList(inputs));
   }
 
   visitConditional(Conditional node) {
     SsaBranchBuilder brancher = new SsaBranchBuilder(this, node);
     brancher.handleConditional(() => visit(node.condition),
                                () => visit(node.thenExpression),
                                () => visit(node.elseExpression));
   }
 
   visitStringInterpolation(StringInterpolation node) {
@@ skipping 163 matching lines @@
                                        handler.labels()),
           joinBlock);
     }
     handler.close();
   }
 
   visitLiteralMap(LiteralMap node) {
     if (node.isConst()) {
       ConstantHandler handler = compiler.constantHandler;
       Constant constant = handler.compileNodeWithDefinitions(node, elements);
-      stack.add(graph.addConstant(constant));
+      stack.add(graph.addConstant(constant, compiler));
       return;
     }
     List<HInstruction> inputs = <HInstruction>[];
     for (Link<Node> link = node.entries.nodes;
          !link.isEmpty;
          link = link.tail) {
       visit(link.head);
       inputs.add(pop());
       inputs.add(pop());
     }
-    HLiteralList keyValuePairs = new HLiteralList(inputs);
+    HLiteralList keyValuePairs = buildLiteralList(inputs);
     add(keyValuePairs);
     HType mapType = new HType.nonNullSubtype(
         backend.mapLiteralClass.computeType(compiler), compiler);
     pushInvokeStatic(node, backend.getMapMaker(), [keyValuePairs], mapType);
   }
 
   visitLiteralMapEntry(LiteralMapEntry node) {
     visit(node.value);
     visit(node.key);
   }
@@ skipping 140 matching lines @@
     //   l: while (true) {
     //    switch (target) {
     //       case 1: s_1; break l;
     //       case 2: s_2; target = i; continue l;
     //       ...
     //       case n: s_n; target = j; continue l;
     //     }
     //   }
 
     TargetElement switchTarget = elements[node];
-    HInstruction initialValue = graph.addConstantNull(constantSystem);
+    HInstruction initialValue = graph.addConstantNull(compiler);
     localsHandler.updateLocal(switchTarget, initialValue);
 
     JumpHandler jumpHandler = createJumpHandler(node, isLoopJump: false);
     var switchCases = node.cases;
     if (!hasDefault) {
       // Use [:null:] as the marker for a synthetic default clause.
       // The synthetic default is added because otherwise, there would be no
       // good place to give a default value to the local.
       switchCases = node.cases.nodes.toList()..add(null);
     }
@@ skipping 12 matching lines @@
       }
       return constantList;
     }
     bool isDefaultCase(SwitchCase switchCase) {
       return switchCase == null || switchCase.isDefaultCase;
     }
     void buildSwitchCase(SwitchCase switchCase) {
       if (switchCase != null) {
         // Generate 'target = i; break;' for switch case i.
         int index = caseIndex[switchCase];
-        HInstruction value = graph.addConstantInt(index, constantSystem);
+        HInstruction value = graph.addConstantInt(index, compiler);
         localsHandler.updateLocal(switchTarget, value);
       } else {
         // Generate synthetic default case 'target = null; break;'.
-        HInstruction value = graph.addConstantNull(constantSystem);
+        HInstruction value = graph.addConstantNull(compiler);
         localsHandler.updateLocal(switchTarget, value);
       }
       jumpTargets[switchTarget].generateBreak();
     }
     handleSwitch(node,
                  jumpHandler,
                  buildExpression,
                  switchCases,
                  getConstants,
                  isDefaultCase,
                  buildSwitchCase);
     jumpHandler.close();
 
     HInstruction buildCondition() =>
-        graph.addConstantBool(true, constantSystem);
+        graph.addConstantBool(true, compiler);
 
     void buildSwitch() {
       HInstruction buildExpression() {
         return localsHandler.readLocal(switchTarget);
       }
       Iterable<Constant> getConstants(SwitchCase switchCase) {
         return <Constant>[constantSystem.createInt(caseIndex[switchCase])];
       }
       void buildSwitchCase(SwitchCase switchCase) {
         visit(switchCase.statements);
@@ skipping 74 matching lines @@
     bool hasDefault = false;
     Element getFallThroughErrorElement = backend.getFallThroughError();
     HasNextIterator<Node> caseIterator =
         new HasNextIterator<Node>(switchCases.iterator);
     while (caseIterator.hasNext) {
       SwitchCase switchCase = caseIterator.next();
       List<Constant> caseConstants = <Constant>[];
       HBasicBlock block = graph.addNewBlock();
       for (Constant constant in getConstants(switchCase)) {
         caseConstants.add(constant);
-        HConstant hConstant = graph.addConstant(constant);
+        HConstant hConstant = graph.addConstant(constant, compiler);
         switchInstruction.inputs.add(hConstant);
         hConstant.usedBy.add(switchInstruction);
         expressionBlock.addSuccessor(block);
       }
       matchExpressions.add(caseConstants);
 
       if (isDefaultCase(switchCase)) {
         // An HSwitch has n inputs and n+1 successors, the last being the
         // default case.
         expressionBlock.addSuccessor(block);
@@ skipping 166 matching lines @@
 
       void pushCondition(CatchBlock catchBlock) {
         if (catchBlock.onKeyword != null) {
           DartType type = elements.getType(catchBlock.type);
           if (type == null) {
             compiler.internalError('On with no type', node: catchBlock.type);
           }
           if (type.isMalformed) {
             // TODO(johnniwinther): Handle malformed types in [HIs] instead.
             HInstruction condition =
-                graph.addConstantBool(true, constantSystem);
+                graph.addConstantBool(true, compiler);
             stack.add(condition);
           } else {
             // TODO(karlkose): support type arguments here.
             HInstruction condition = new HIs(type,
                                              <HInstruction>[unwrappedException],
                                              HIs.RAW_CHECK);
             push(condition);
           }
         } else {
           VariableDefinitions declaration = catchBlock.formals.nodes.head;
           HInstruction condition = null;
           if (declaration.type == null) {
-            condition = graph.addConstantBool(true, constantSystem);
+            condition = graph.addConstantBool(true, compiler);
             stack.add(condition);
           } else {
             // TODO(aprelev@gmail.com): Once old catch syntax is removed
             // "if" condition above and this "else" branch should be deleted as
             // type of declared variable won't matter for the catch
             // condition.
             DartType type = elements.getType(declaration.type);
             if (type == null) {
               compiler.cancel('Catch with unresolved type', node: catchBlock);
             }
@@ skipping 173 matching lines @@
 
   visitNode(Node node) {
     builder.compiler.internalError('unexpected node', node: node);
   }
 
   void visitExpression(Node node) {
     node.accept(builder);
     HInstruction expression = builder.pop();
     if (!expression.isConstantString()) {
       expression = new HStringify(expression, node);
+      expression.instructionType = builder.backend.stringType;
       builder.add(expression);
     }
     result = (result == null) ? expression : concat(result, expression);
   }
 
   void visitStringInterpolation(StringInterpolation node) {
     node.visitChildren(this);
   }
 
   void visitStringInterpolationPart(StringInterpolationPart node) {
     visit(node.expression);
     visit(node.string);
   }
 
   void visitStringJuxtaposition(StringJuxtaposition node) {
     node.visitChildren(this);
   }
 
   void visitNodeList(NodeList node) {
      node.visitChildren(this);
   }
 
   HInstruction concat(HInstruction left, HInstruction right) {
     HInstruction instruction = new HStringConcat(left, right, diagnosticNode);
+    instruction.instructionType = builder.backend.stringType;
     builder.add(instruction);
     return instruction;
   }
 }
 
 /**
  * This class visits the method that is a candidate for inlining and
  * finds whether it is too difficult to inline.
  */
 class InlineWeeder extends Visitor {
@@ skipping 253 matching lines @@
       }
     }
 
     void visitThen() {
       right();
       boolifiedRight = builder.popBoolified();
     }
 
     handleIf(visitCondition, visitThen, null);
     HConstant notIsAnd =
-        builder.graph.addConstantBool(!isAnd, builder.constantSystem);
+        builder.graph.addConstantBool(!isAnd, builder.compiler);
     HPhi result = new HPhi.manyInputs(null,
                                       <HInstruction>[boolifiedRight, notIsAnd]);
     builder.current.addPhi(result);
     builder.stack.add(result);
   }
 
   void handleLogicalAndOrWithLeftNode(Node left,
                                       void visitRight(),
                                       {bool isAnd}) {
     // This method is similar to [handleLogicalAndOr] but optimizes the case
@@ skipping 69 matching lines @@
           new HSubGraphBlockInformation(elseBranch.graph));
 
     HBasicBlock conditionStartBlock = conditionBranch.block;
     conditionStartBlock.setBlockFlow(info, joinBlock);
     SubGraph conditionGraph = conditionBranch.graph;
     HIf branch = conditionGraph.end.last;
     assert(branch is HIf);
     branch.blockInformation = conditionStartBlock.blockFlow;
   }
 }