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

sdk/lib/_internal/compiler/implementation/ssa/nodes.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;
 
 abstract class HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBailoutTarget(HBailoutTarget node);
   R visitBitAnd(HBitAnd node);
@@ skipping 144 matching lines @@
   }
 
   HBasicBlock addNewLoopHeaderBlock(TargetElement target,
                                     List<LabelElement> labels) {
     HBasicBlock result = addNewBlock();
     result.loopInformation =
         new HLoopInformation(result, target, labels);
     return result;
   }
 
-  static HType mapConstantTypeToSsaType(Constant constant) {
+  static HType mapConstantTypeToSsaType(Constant constant, Compiler compiler) {
+    JavaScriptBackend backend = compiler.backend;
     if (constant.isNull()) return HType.NULL;
     if (constant.isBool()) return HType.BOOLEAN;
     if (constant.isInt()) return HType.INTEGER;
     if (constant.isDouble()) return HType.DOUBLE;
-    if (constant.isString()) return HType.STRING;
-    if (constant.isList()) return HType.READABLE_ARRAY;
+    if (constant.isString()) return backend.stringType;
+    if (constant.isList()) return backend.readableArrayType;
     if (constant.isFunction()) return HType.UNKNOWN;
     if (constant.isSentinel()) return HType.UNKNOWN;
     // TODO(sra): What is the type of the prototype of an interceptor?
     if (constant.isInterceptor()) return HType.UNKNOWN;
-    // TODO(kasperl): This seems a bit fishy, but we do not have the
-    // compiler at hand so we cannot use the usual HType factory
-    // methods. At some point this should go away.
     ObjectConstant objectConstant = constant;
-    TypeMask mask = new TypeMask.nonNullExact(objectConstant.type);
-    return new HBoundedType(mask);
+    return new HBoundedType(new TypeMask.nonNullExact(objectConstant.type));
   }
 
-  HConstant addConstant(Constant constant) {
+  HConstant addConstant(Constant constant, Compiler compiler) {
     HConstant result = constants[constant];
     if (result == null) {
-      HType type = mapConstantTypeToSsaType(constant);
+      HType type = mapConstantTypeToSsaType(constant, compiler);
       result = new HConstant.internal(constant, type);
       entry.addAtExit(result);
       constants[constant] = result;
     } else if (result.block == null) {
       // The constant was not used anymore.
       entry.addAtExit(result);
     }
     return result;
   }
 
-  HConstant addConstantInt(int i, ConstantSystem constantSystem) {
-    return addConstant(constantSystem.createInt(i));
+  HConstant addConstantInt(int i, Compiler compiler) {
+    return addConstant(compiler.backend.constantSystem.createInt(i), compiler);
   }
 
-  HConstant addConstantDouble(double d, ConstantSystem constantSystem) {
-    return addConstant(constantSystem.createDouble(d));
+  HConstant addConstantDouble(double d, Compiler compiler) {
+    return addConstant(
+        compiler.backend.constantSystem.createDouble(d), compiler);
   }
 
   HConstant addConstantString(DartString str,
                               Node diagnosticNode,
-                              ConstantSystem constantSystem) {
-    return addConstant(constantSystem.createString(str, diagnosticNode));
+                              Compiler compiler) {
+    return addConstant(
+        compiler.backend.constantSystem.createString(str, diagnosticNode),
+        compiler);
   }
 
-  HConstant addConstantBool(bool value, ConstantSystem constantSystem) {
-    return addConstant(constantSystem.createBool(value));
+  HConstant addConstantBool(bool value, Compiler compiler) {
+    return addConstant(
+        compiler.backend.constantSystem.createBool(value), compiler);
   }
 
-  HConstant addConstantNull(ConstantSystem constantSystem) {
-    return addConstant(constantSystem.createNull());
+  HConstant addConstantNull(Compiler compiler) {
+    return addConstant(compiler.backend.constantSystem.createNull(), compiler);
   }
 
   void finalize() {
     addBlock(exit);
     exit.open();
     exit.close(new HExit());
     assignDominators();
   }
 
   void assignDominators() {
@@ skipping 601 matching lines @@
   bool isArray(Compiler compiler) =>
       instructionType.isArray(compiler);
   bool isReadableArray(Compiler compiler) =>
       instructionType.isReadableArray(compiler);
   bool isMutableArray(Compiler compiler) =>
       instructionType.isMutableArray(compiler);
   bool isExtendableArray(Compiler compiler) =>
       instructionType.isExtendableArray(compiler);
   bool isFixedArray(Compiler compiler) =>
       instructionType.isFixedArray(compiler);
+  bool isString(Compiler compiler) =>
+      instructionType.isString(compiler);
+  bool isPrimitive(Compiler compiler) =>
+      instructionType.isPrimitive(compiler);
+  bool isPrimitiveOrNull(Compiler compiler) =>
+      instructionType.isPrimitiveOrNull(compiler);
   bool isBoolean() => instructionType.isBoolean();
   bool isInteger() => instructionType.isInteger();
   bool isIntegerOrNull() => instructionType.isIntegerOrNull();
   bool isDouble() => instructionType.isDouble();
   bool isDoubleOrNull() => instructionType.isDoubleOrNull();
   bool isNumber() => instructionType.isNumber();
   bool isNumberOrNull() => instructionType.isNumberOrNull();
-  bool isString() => instructionType.isString();
-  bool isPrimitive() => instructionType.isPrimitive();
-  bool isPrimitiveOrNull() => instructionType.isPrimitiveOrNull();
   bool isNull() => instructionType.isNull();
   bool canBeNull() => instructionType.canBeNull();
   bool canBePrimitive(Compiler compiler) =>
       instructionType.canBePrimitive(compiler);
   bool canBePrimitiveArray(Compiler compiler) =>
       instructionType.canBePrimitiveArray(compiler);
 
   bool isIndexable(Compiler compiler) =>
       instructionType.isIndexable(compiler);
   bool isMutableIndexable(Compiler compiler) =>
@@ skipping 1271 matching lines @@
   toString() => 'static store ${element.name}';
   accept(HVisitor visitor) => visitor.visitStaticStore(this);
 
   int typeCode() => HInstruction.STATIC_STORE_TYPECODE;
   bool typeEquals(other) => other is HStaticStore;
   bool dataEquals(HStaticStore other) => element == other.element;
   bool isJsStatement() => true;
 }
 
 class HLiteralList extends HInstruction {
-  HLiteralList(inputs) : super(inputs) {
-    instructionType = HType.EXTENDABLE_ARRAY;
+  HLiteralList(List<HInstruction> inputs, HType type) : super(inputs) {
+    instructionType = type;
   }
   toString() => 'literal list';
   accept(HVisitor visitor) => visitor.visitLiteralList(this);
 }
 
 /**
  * The primitive array indexing operation. Note that this instruction
  * does not throw because we generate the checks explicitly.
  */
 class HIndex extends HInstruction {
@@ skipping 151 matching lines @@
   HRangeConversion(HInstruction input) : super(<HInstruction>[input]) {
     sourceElement = input.sourceElement;
     // We currently only do range analysis for integers.
     instructionType = HType.INTEGER;
   }
   accept(HVisitor visitor) => visitor.visitRangeConversion(this);
 }
 
 class HStringConcat extends HInstruction {
   final Node node;
-  HStringConcat(HInstruction left, HInstruction right, this.node)
+  HStringConcat(HInstruction left, HInstruction right, this.node, HType type)
       : super(<HInstruction>[left, right]) {
     // TODO(sra): Until Issue 9293 is fixed, this false dependency keeps the
     // concats bunched with stringified inputs for much better looking code with
     // fewer temps.
     sideEffects.setDependsOnSomething();
-    instructionType = HType.STRING;
+    instructionType = type;
   }
 
   HInstruction get left => inputs[0];
   HInstruction get right => inputs[1];
 
   accept(HVisitor visitor) => visitor.visitStringConcat(this);
   toString() => "string concat";
 }
 
 /**
  * The part of string interpolation which converts and interpolated expression
  * into a String value.
  */
 class HStringify extends HInstruction {
   final Node node;
-  HStringify(HInstruction input, this.node) : super(<HInstruction>[input]) {
+  HStringify(HInstruction input, this.node, HType type)
+      : super(<HInstruction>[input]) {
     sideEffects.setAllSideEffects();
     sideEffects.setDependsOnSomething();
-    instructionType = HType.STRING;
+    instructionType = type;
   }
 
   accept(HVisitor visitor) => visitor.visitStringify(this);
   toString() => "stringify";
 }
 
 /** Non-block-based (aka. traditional) loop information. */
 class HLoopInformation {
   final HBasicBlock header;
   final List<HBasicBlock> blocks;
@@ skipping 326 matching lines @@
   HBasicBlock get start => expression.start;
   HBasicBlock get end {
     // We don't create a switch block if there are no cases.
     assert(!statements.isEmpty);
     return statements.last.end;
   }
 
   bool accept(HStatementInformationVisitor visitor) =>
       visitor.visitSwitchInfo(this);
 }