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

sdk/lib/_internal/compiler/implementation/ssa/tracer.dart

 // Copyright (c) 2013, 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 tracer;
 
 import 'dart:async' show EventSink;
 
 import 'ssa.dart';
 import '../js_backend/js_backend.dart';
 import '../dart2jslib.dart';
 
 const bool GENERATE_SSA_TRACE = false;
 const String SSA_TRACE_FILTER = null;
 
 class HTracer extends HGraphVisitor implements Tracer {
+  Compiler compiler;
   JavaScriptItemCompilationContext context;
   int indent = 0;
   final EventSink<String> output;
   final bool enabled = GENERATE_SSA_TRACE;
   bool traceActive = false;
 
   HTracer(this.output);
 
   void close() {
     if (enabled) output.close();
   }
 
   void traceCompilation(String methodName,
-                        JavaScriptItemCompilationContext compilationContext) {
+                        JavaScriptItemCompilationContext compilationContext,
+                        Compiler compiler) {
     if (!enabled) return;
     this.context = compilationContext;
+    this.compiler = compiler;
     traceActive =
         SSA_TRACE_FILTER == null || methodName.contains(SSA_TRACE_FILTER);
     if (!traceActive) return;
     tag("compilation", () {
       printProperty("name", methodName);
       printProperty("method", methodName);
       printProperty("date", new DateTime.now().millisecondsSinceEpoch);
     });
   }
 
@@ skipping 42 matching lines @@
       String depends = instruction.sideEffects.dependsOnSomething() ? '?' : '';
       addIndent();
       String temporaryId = stringifier.temporaryId(instruction);
       String instructionString = stringifier.visit(instruction);
       add("$bci $uses $temporaryId $instructionString $changes $depends <|@\n");
     }
   }
 
   void visitBasicBlock(HBasicBlock block) {
     HInstructionStringifier stringifier =
-        new HInstructionStringifier(context, block);
+        new HInstructionStringifier(context, block, compiler);
     assert(block.id != null);
     tag("block", () {
       printProperty("name", "B${block.id}");
       printProperty("from_bci", -1);
       printProperty("to_bci", -1);
       addPredecessors(block);
       addSuccessors(block);
       printEmptyProperty("xhandlers");
       printEmptyProperty("flags");
       if (block.dominator != null) {
@@ skipping 52 matching lines @@
   }
 
   void addIndent() {
     for (int i = 0; i < indent; i++) {
       add("  ");
     }
   }
 }
 
 class HInstructionStringifier implements HVisitor<String> {
-  JavaScriptItemCompilationContext context;
-  HBasicBlock currentBlock;
+  final Compiler compiler;
+  final JavaScriptItemCompilationContext context;
+  final HBasicBlock currentBlock;
 
-  HInstructionStringifier(this.context, this.currentBlock);
+  HInstructionStringifier(this.context, this.currentBlock, this.compiler);
 
   visit(HInstruction node) => node.accept(this);
 
   String temporaryId(HInstruction instruction) {
     String prefix;
     HType type = instruction.instructionType;
-    if (type == HType.MUTABLE_ARRAY) {
+    if (type.isMutableArray(compiler)) {
       prefix = 'm';
-    } else if (type == HType.READABLE_ARRAY) {
+    } else if (type.isReadableArray(compiler)) {
       prefix = 'a';
-    } else if (type == HType.EXTENDABLE_ARRAY) {
+    } else if (type.isExtendableArray(compiler)) {
       prefix = 'e';
     } else if (type == HType.BOOLEAN) {
       prefix = 'b';
     } else if (type == HType.INTEGER) {
       prefix = 'i';
     } else if (type == HType.DOUBLE) {
       prefix = 'd';
     } else if (type == HType.NUMBER) {
       prefix = 'n';
-    } else if (type == HType.STRING) {
+    } else if (type.isString(compiler)) {
       prefix = 's';
     } else if (type == HType.UNKNOWN) {
       prefix = 'v';
     } else if (type == HType.CONFLICTING) {
       prefix = 'c';
-    } else if (type == HType.INDEXABLE_PRIMITIVE) {
+    } else if (type.isIndexable(compiler)) {
       prefix = 'r';
     } else if (type == HType.NULL) {
       prefix = 'u';
     } else {
       prefix = 'U';
     }
     return "$prefix${instruction.id}";
   }
 
   String visitBailoutTarget(HBailoutTarget node) {
@@ skipping 289 matching lines @@
       finallyBlock = 'B${node.finallyBlock.id}';
     }
 
     return "Try: $tryBlock, Catch: $catchBlock, Finally: $finallyBlock, "
         "Join: B${successors.last.id}";
   }
 
   String visitTypeGuard(HTypeGuard node) {
     String type;
     HType guardedType = node.guardedType;
-    if (guardedType == HType.MUTABLE_ARRAY) {
+    if (guardedType.isExtendableArray(compiler)) {
+      type = "extendable_array";
+    } else if (guardedType.isMutableArray(compiler)) {
       type = "mutable_array";
-    } else if (guardedType == HType.READABLE_ARRAY) {
+    } else if (guardedType.isReadableArray(compiler)) {
       type = "readable_array";
-    } else if (guardedType == HType.EXTENDABLE_ARRAY) {
-      type = "extendable_array";
     } else if (guardedType == HType.BOOLEAN) {
       type = "bool";
     } else if (guardedType == HType.INTEGER) {
       type = "integer";
     } else if (guardedType == HType.DOUBLE) {
       type = "double";
     } else if (guardedType == HType.NUMBER) {
       type = "number";
-    } else if (guardedType == HType.STRING) {
+    } else if (guardedType.isString(compiler)) {
       type = "string";
-    } else if (guardedType == HType.INDEXABLE_PRIMITIVE) {
+    } else if (guardedType.isIndexable(compiler)) {
       type = "string_or_array";
     } else if (guardedType == HType.UNKNOWN) {
       type = 'unknown';
     } else {
       throw new CompilerCancelledException('Unexpected type guard: $type');
     }
     HInstruction guarded = node.guarded;
     HInstruction bailoutTarget = node.bailoutTarget;
     StringBuffer envBuffer = new StringBuffer();
     List<HInstruction> inputs = node.inputs;
@@ skipping 21 matching lines @@
         ? temporaryId(node.inputs[1])
         : '';
     return "TypeConversion: ${temporaryId(node.checkedInput)} to "
       "${node.instructionType} $otherInput";
   }
 
   String visitRangeConversion(HRangeConversion node) {
     return "RangeConversion: ${node.checkedInput}";
   }
 }