Add named constants for all type codes

lib/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.
 
 interface HVisitor<R> {
   R visitAdd(HAdd node);
   R visitBailoutTarget(HBailoutTarget node);
   R visitBitAnd(HBitAnd node);
   R visitBitNot(HBitNot node);
   R visitBitOr(HBitOr node);
@@ skipping 740 matching lines @@
   // Changes flags.
   static final int FLAG_CHANGES_SOMETHING    = 0;
   static final int FLAG_CHANGES_COUNT        = FLAG_CHANGES_SOMETHING + 1;
 
   // Depends flags (one for each changes flag).
   static final int FLAG_DEPENDS_ON_SOMETHING = FLAG_CHANGES_COUNT;
 
   // Other flags.
   static final int FLAG_USE_GVN              = FLAG_DEPENDS_ON_SOMETHING + 1;
 
+  // Type codes.
+  static final int UNDEFINED_TYPECODE = -1;
+  static final int BOOLIFY_TYPECODE = 0;
+  static final int TYPE_GUARD_TYPECODE = 1;
+  static final int BOUNDS_CHECK_TYPECODE = 2;
+  static final int INTEGER_CHECK_TYPECODE = 3;
+  static final int INVOKE_INTERCEPTOR_TYPECODE = 4;
+  static final int ADD_TYPECODE = 5;
+  static final int DIVIDE_TYPECODE = 6;
+  static final int MODULO_TYPECODE = 7;
+  static final int MULTIPLY_TYPECODE = 8;
+  static final int SUBTRACT_TYPECODE = 9;
+  static final int TRUNCATING_DIVIDE_TYPECODE = 10;
+  static final int SHIFT_LEFT_TYPECODE = 11;
+  static final int SHIFT_RIGHT_TYPECODE = 12;
+  static final int BIT_OR_TYPECODE = 13;
+  static final int BIT_AND_TYPECODE = 14;
+  static final int BIT_XOR_TYPECODE = 15;
+  static final int NEGATE_TYPECODE = 16;
+  static final int BIT_NOT_TYPECODE = 17;
+  static final int NOT_TYPECODE = 18;
+  static final int EQUALS_TYPECODE = 19;
+  static final int IDENTITY_TYPECODE = 20;
+  static final int GREATER_TYPECODE = 21;
+  static final int GREATER_EQUAL_TYPECODE = 22;
+  static final int LESS_TYPECODE = 23;
+  static final int LESS_EQUAL_TYPECODE = 24;
+  static final int STATIC_TYPECODE = 25;
+  static final int STATIC_STORE_TYPECODE = 26;
+  static final int FIELD_GET_TYPECODE = 27;
+  static final int TYPE_CONVERSION_TYPECODE = 28;
+  static final int BAILOUT_TARGET_TYPECODE = 29;
+  static final int INVOKE_STATIC_TYPECODE = 30;
+
   HInstruction(this.inputs)
       : id = idCounter++,
         usedBy = <HInstruction>[];
 
   int hashCode() => id;
 
   bool getFlag(int position) => (flags & (1 << position)) != 0;
   void setFlag(int position) { flags |= (1 << position); }
   void clearFlag(int position) { flags &= ~(1 << position); }
 
@@ skipping 112 matching lines @@
     int result = typeCode();
     int length = inputs.length;
     for (int i = 0; i < length; i++) {
       result = (result * 19) + (inputs[i].id) + (result >> 7);
     }
     return result;
   }
 
   // These methods should be overwritten by instructions that
   // participate in global value numbering.
-  int typeCode() => -1;
+  int typeCode() => HInstruction.UNDEFINED_TYPECODE;
   bool typeEquals(HInstruction other) => false;
   bool dataEquals(HInstruction other) => false;
 
   abstract accept(HVisitor visitor);
 
   void notifyAddedToBlock(HBasicBlock targetBlock) {
     assert(!isInBasicBlock());
     assert(block === null);
     // Add [this] to the inputs' uses.
     for (int i = 0; i < inputs.length; i++) {
@@ skipping 145 matching lines @@
 class HBoolify extends HInstruction {
   HBoolify(HInstruction value) : super(<HInstruction>[value]);
   void prepareGvn(HTypeMap types) {
     assert(!hasSideEffects(types));
     setUseGvn();
   }
 
   HType get guaranteedType => HType.BOOLEAN;
 
   accept(HVisitor visitor) => visitor.visitBoolify(this);
-  int typeCode() => 0;
+  int typeCode() => HInstruction.BOOLIFY_TYPECODE;
   bool typeEquals(other) => other is HBoolify;
   bool dataEquals(HInstruction other) => true;
 }
 
 /**
  * A [HCheck] instruction is an instruction that might do a dynamic
  * check at runtime on another instruction. To have proper instruction
  * dependencies in the graph, instructions that depend on the check
  * being done reference the [HCheck] instruction instead of the
  * instruction itself.
@@ skipping 14 matching lines @@
   HBailoutTarget(this.state) : super(<HInstruction>[]);
   void prepareGvn(HTypeMap types) {
     assert(!hasSideEffects(types));
     setUseGvn();
   }
 
   bool isControlFlow() => true;
   bool isStatement(HTypeMap types) => isEnabled;
 
   accept(HVisitor visitor) => visitor.visitBailoutTarget(this);
-  int typeCode() => 29;
+  int typeCode() => HInstruction.BAILOUT_TARGET_TYPECODE;
   bool typeEquals(other) => other is HBailoutTarget;
   bool dataEquals(HBailoutTarget other) => other.state == state;
 }
 
 class HTypeGuard extends HCheck {
   final HType guardedType;
   bool isEnabled = false;
 
   HTypeGuard(this.guardedType, HInstruction guarded, HInstruction bailoutTarget)
       : super(<HInstruction>[guarded, bailoutTarget]);
 
   HInstruction get guarded => inputs[0];
   HInstruction get checkedInput => guarded;
   HBailoutTarget get bailoutTarget => inputs[1];
   int get state => bailoutTarget.state;
 
   HType computeTypeFromInputTypes(HTypeMap types) {
     return isEnabled ? guardedType : types[guarded];
   }
 
   HType get guaranteedType => isEnabled ? guardedType : HType.UNKNOWN;
 
   bool isControlFlow() => true;
 
   bool isStatement(HTypeMap types) => isEnabled;
 
   accept(HVisitor visitor) => visitor.visitTypeGuard(this);
-  int typeCode() => 1;
+  int typeCode() => HInstruction.TYPE_GUARD_TYPECODE;
   bool typeEquals(other) => other is HTypeGuard;
   bool dataEquals(HTypeGuard other) => guardedType == other.guardedType;
 }
 
 class HBoundsCheck extends HCheck {
   static final int ALWAYS_FALSE = 0;
   static final int FULL_CHECK = 1;
   static final int ALWAYS_ABOVE_ZERO = 2;
   static final int ALWAYS_TRUE = 3;
   /**
    * Details which tests have been done statically during compilation.
    * Default is that all checks must be performed dynamically.
    */
   int staticChecks = FULL_CHECK;
 
   HBoundsCheck(length, index) : super(<HInstruction>[length, index]);
 
   HInstruction get length => inputs[1];
   HInstruction get index => inputs[0];
   bool isControlFlow() => true;
 
   HType get guaranteedType => HType.INTEGER;
 
   accept(HVisitor visitor) => visitor.visitBoundsCheck(this);
-  int typeCode() => 2;
+  int typeCode() => HInstruction.BOUNDS_CHECK_TYPECODE;
   bool typeEquals(other) => other is HBoundsCheck;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HIntegerCheck extends HCheck {
   bool alwaysFalse = false;
 
   HIntegerCheck(value) : super(<HInstruction>[value]);
 
   HInstruction get value => inputs[0];
   bool isControlFlow() => true;
 
   HType get guaranteedType => HType.INTEGER;
 
   HType computeDesiredTypeForInput(HInstruction input, HTypeMap types) {
     // If the desired type of the input is already a number, we want
     // to specialize it to an integer.
     return input.isNumber(types)
       ? HType.INTEGER
       : super.computeDesiredTypeForInput(input, types);
   }
 
   accept(HVisitor visitor) => visitor.visitIntegerCheck(this);
-  int typeCode() => 3;
+  int typeCode() => HInstruction.INTEGER_CHECK_TYPECODE;
   bool typeEquals(other) => other is HIntegerCheck;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HConditionalBranch extends HControlFlow {
   HConditionalBranch(inputs) : super(inputs);
   HInstruction get condition => inputs[0];
   HBasicBlock get trueBranch => block.successors[0];
   HBasicBlock get falseBranch => block.successors[1];
   abstract toString();
@@ skipping 66 matching lines @@
 }
 
 class HInvokeDynamicSetter extends HInvokeDynamicField {
   HInvokeDynamicSetter(selector, element, receiver, value)
     : super(selector, element, [receiver, value]);
   toString() => 'invoke dynamic setter: $selector';
   accept(HVisitor visitor) => visitor.visitInvokeDynamicSetter(this);
 }
 
 class HInvokeStatic extends HInvoke {
-  static final int INVOKE_INTERCEPTOR_TYPECODE = 4;
-  static final int INVOKE_STATIC_TYPECODE = 30;
-
   /** The first input must be the target. */
   HInvokeStatic(inputs, [HType knownType = HType.UNKNOWN]) : super(inputs) {
     guaranteedType = knownType;
   }
 
   toString() => 'invoke static: ${element.name}';
   accept(HVisitor visitor) => visitor.visitInvokeStatic(this);
-  int typeCode() => INVOKE_STATIC_TYPECODE;
+  int typeCode() => HInstruction.INVOKE_STATIC_TYPECODE;
   Element get element => target.element;
   HStatic get target => inputs[0];
 
   HType computeDesiredTypeForInput(HInstruction input, HTypeMap types) {
     // TODO(floitsch): we want the target to be a function.
     if (input == target) return HType.UNKNOWN;
     return computeDesiredTypeForNonTargetInput(input, types);
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input,
@@ skipping 68 matching lines @@
   void prepareGvn(HTypeMap types) {
     if (isLengthGetterOnStringOrArray(types)) {
       setUseGvn();
       clearAllSideEffects();
       setDependsOnSomething();
     } else {
       setAllSideEffects();
     }
   }
 
-  int typeCode() => HInvokeStatic.INVOKE_INTERCEPTOR_TYPECODE;
+  int typeCode() => HInstruction.INVOKE_INTERCEPTOR_TYPECODE;
   bool typeEquals(other) => other is HInvokeInterceptor;
   bool dataEquals(HInvokeInterceptor other) {
     return getter == other.getter && name == other.name;
   }
 }
 
 abstract class HFieldAccess extends HInstruction {
   final Element element;
   final SourceString fieldName;
   final LibraryElement library;
@@ skipping 22 matching lines @@
   HInstruction get receiver => inputs[0];
 
   accept(HVisitor visitor) => visitor.visitFieldGet(this);
 
   void prepareGvn(HTypeMap types) {
     setUseGvn();
     clearAllSideEffects();
     if (!isFinalOrConst) setDependsOnSomething();
   }
 
-  int typeCode() => 27;
+  int typeCode() => HInstruction.FIELD_GET_TYPECODE;
   bool typeEquals(other) => other is HFieldGet;
   bool dataEquals(HFieldGet other) => element == other.element;
   String toString() => "FieldGet ${element == null ? fieldName : element}";
 }
 
 class HFieldSet extends HFieldAccess {
   HFieldSet(SourceString name,
             LibraryElement library,
             HInstruction receiver,
             HInstruction value)
@@ skipping 155 matching lines @@
   // TODO(1603): The class should be marked as abstract.
   abstract BinaryOperation get operation();
 }
 
 class HAdd extends HBinaryArithmetic {
   HAdd(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitAdd(this);
 
   AddOperation get operation => const AddOperation();
-  int typeCode() => 5;
+  int typeCode() => HInstruction.ADD_TYPECODE;
   bool typeEquals(other) => other is HAdd;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HDivide extends HBinaryArithmetic {
   HDivide(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitDivide(this);
 
   HType computeTypeFromInputTypes(HTypeMap types) {
     if (left.isNumber(types)) return HType.DOUBLE;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input,
                                             HTypeMap types) {
     // A division can never return an integer. So don't ask for integer inputs.
     if (isInteger(types)) return HType.UNKNOWN;
     return super.computeDesiredTypeForNonTargetInput(input, types);
   }
 
   DivideOperation get operation => const DivideOperation();
-  int typeCode() => 6;
+  int typeCode() => HInstruction.DIVIDE_TYPECODE;
   bool typeEquals(other) => other is HDivide;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HModulo extends HBinaryArithmetic {
   HModulo(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitModulo(this);
 
   ModuloOperation get operation => const ModuloOperation();
-  int typeCode() => 7;
+  int typeCode() => HInstruction.MODULO_TYPECODE;
   bool typeEquals(other) => other is HModulo;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HMultiply extends HBinaryArithmetic {
   HMultiply(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitMultiply(this);
 
   MultiplyOperation get operation => const MultiplyOperation();
-  int typeCode() => 8;
+  int typeCode() => HInstruction.MULTIPLY_TYPECODE;
   bool typeEquals(other) => other is HMultiply;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HSubtract extends HBinaryArithmetic {
   HSubtract(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitSubtract(this);
 
   SubtractOperation get operation => const SubtractOperation();
-  int typeCode() => 9;
+  int typeCode() => HInstruction.SUBTRACT_TYPECODE;
   bool typeEquals(other) => other is HSubtract;
   bool dataEquals(HInstruction other) => true;
 }
 
 /**
  * An [HSwitch] instruction has one input for the incoming
  * value, and one input per constant that it can switch on.
  * Its block has one successor per constant, and one for the default.
  */
 class HSwitch extends HControlFlow {
@@ skipping 14 matching lines @@
   String toString() => "HSwitch cases = $inputs";
 }
 
 class HTruncatingDivide extends HBinaryArithmetic {
   HTruncatingDivide(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitTruncatingDivide(this);
 
   TruncatingDivideOperation get operation
       => const TruncatingDivideOperation();
-  int typeCode() => 10;
+  int typeCode() => HInstruction.TRUNCATING_DIVIDE_TYPECODE;
   bool typeEquals(other) => other is HTruncatingDivide;
   bool dataEquals(HInstruction other) => true;
 }
 
 
 // TODO(floitsch): Should HBinaryArithmetic really be the super class of
 // HBinaryBitOp?
 class HBinaryBitOp extends HBinaryArithmetic {
   HBinaryBitOp(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
@@ skipping 35 matching lines @@
   // shift count is guaranteed to be an integer in the [0,31] range.
   bool isBuiltin(HTypeMap types) {
     if (!left.isNumber(types) || !right.isConstantInteger()) return false;
     HConstant rightConstant = right;
     IntConstant intConstant = rightConstant.constant;
     int count = intConstant.value;
     return count >= 0 && count <= 31;
   }
 
   ShiftLeftOperation get operation => const ShiftLeftOperation();
-  int typeCode() => 11;
+  int typeCode() => HInstruction.SHIFT_LEFT_TYPECODE;
   bool typeEquals(other) => other is HShiftLeft;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HShiftRight extends HBinaryBitOp {
   HShiftRight(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitShiftRight(this);
 
   // Shift right cannot be mapped to the native operator easily.
   bool isBuiltin(HTypeMap types) => false;
 
   ShiftRightOperation get operation => const ShiftRightOperation();
-  int typeCode() => 12;
+  int typeCode() => HInstruction.SHIFT_RIGHT_TYPECODE;
   bool typeEquals(other) => other is HShiftRight;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitOr extends HBinaryBitOp {
   HBitOr(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitBitOr(this);
 
   BitOrOperation get operation => const BitOrOperation();
-  int typeCode() => 13;
+  int typeCode() => HInstruction.BIT_OR_TYPECODE;
   bool typeEquals(other) => other is HBitOr;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitAnd extends HBinaryBitOp {
   HBitAnd(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitBitAnd(this);
 
   BitAndOperation get operation => const BitAndOperation();
-  int typeCode() => 14;
+  int typeCode() => HInstruction.BIT_AND_TYPECODE;
   bool typeEquals(other) => other is HBitAnd;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitXor extends HBinaryBitOp {
   HBitXor(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitBitXor(this);
 
   BitXorOperation get operation => const BitXorOperation();
-  int typeCode() => 15;
+  int typeCode() => HInstruction.BIT_XOR_TYPECODE;
   bool typeEquals(other) => other is HBitXor;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HInvokeUnary extends HInvokeStatic {
   HInvokeUnary(HStatic target, HInstruction input)
       : super(<HInstruction>[target, input]);
 
   HInstruction get operand => inputs[1];
 
@@ skipping 31 matching lines @@
   HType computeLikelyType(HTypeMap types) => HType.NUMBER;
 
   abstract UnaryOperation get operation();
 }
 
 class HNegate extends HInvokeUnary {
   HNegate(HStatic target, HInstruction input) : super(target, input);
   accept(HVisitor visitor) => visitor.visitNegate(this);
 
   NegateOperation get operation => const NegateOperation();
-  int typeCode() => 16;
+  int typeCode() => HInstruction.NEGATE_TYPECODE;
   bool typeEquals(other) => other is HNegate;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HBitNot extends HInvokeUnary {
   HBitNot(HStatic target, HInstruction input) : super(target, input);
   accept(HVisitor visitor) => visitor.visitBitNot(this);
 
   HType computeTypeFromInputTypes(HTypeMap types) {
     // All bitwise operations on primitive types either produce an
     // integer or throw an error.
     if (operand.isPrimitive(types)) return HType.INTEGER;
     return HType.UNKNOWN;
   }
 
   HType computeDesiredTypeForNonTargetInput(HInstruction input,
                                             HTypeMap types) {
     HType propagatedType = types[this];
     // Bit operations only work on integers. If there is no desired output
     // type or if it as a number we want to get an integer as input.
     if (propagatedType.isUnknown() || propagatedType.isNumber()) {
       return HType.INTEGER;
     }
     return HType.UNKNOWN;
   }
 
   BitNotOperation get operation => const BitNotOperation();
-  int typeCode() => 17;
+  int typeCode() => HInstruction.BIT_NOT_TYPECODE;
   bool typeEquals(other) => other is HBitNot;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HExit extends HControlFlow {
   HExit() : super(const <HInstruction>[]);
   toString() => 'exit';
   accept(HVisitor visitor) => visitor.visitExit(this);
 }
 
@@ skipping 107 matching lines @@
   }
 
   HType get guaranteedType => HType.BOOLEAN;
 
   // 'Not' only works on booleans. That's what we want as input.
   HType computeDesiredTypeForInput(HInstruction input, HTypeMap types) {
     return HType.BOOLEAN;
   }
 
   accept(HVisitor visitor) => visitor.visitNot(this);
-  int typeCode() => 18;
+  int typeCode() => HInstruction.NOT_TYPECODE;
   bool typeEquals(other) => other is HNot;
   bool dataEquals(HInstruction other) => true;
 }
 
 /**
   * An [HLocalValue] represents a local. Unlike [HParameterValue]s its
   * first use must be in an HLocalSet. That is, [HParameterValue]s have a
   * value from the start, whereas [HLocalValue]s need to be initialized first.
   */
 class HLocalValue extends HInstruction {
@@ skipping 199 matching lines @@
       return HType.READABLE_ARRAY;
     }
     // String equality testing is much more common than array equality testing.
     if (input == right && right.isIndexablePrimitive(types)) {
       return HType.STRING;
     }
     return HType.UNKNOWN;
   }
 
   EqualsOperation get operation => const EqualsOperation();
-  int typeCode() => 19;
+  int typeCode() => HInstruction.EQUALS_TYPECODE;
   bool typeEquals(other) => other is HEquals;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HIdentity extends HRelational {
   HIdentity(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitIdentity(this);
 
   bool isBuiltin(HTypeMap types) => true;
 
   HType get guaranteedType => HType.BOOLEAN;
   HType computeTypeFromInputTypes(HTypeMap types)
       => HType.BOOLEAN;
   // Note that the identity operator really does not care for its input types.
   HType computeDesiredTypeForInput(HInstruction input, HTypeMap types)
       => HType.UNKNOWN;
 
   IdentityOperation get operation => const IdentityOperation();
-  int typeCode() => 20;
+  int typeCode() => HInstruction.IDENTITY_TYPECODE;
   bool typeEquals(other) => other is HIdentity;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HGreater extends HRelational {
   HGreater(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitGreater(this);
 
   GreaterOperation get operation => const GreaterOperation();
-  int typeCode() => 21;
+  int typeCode() => HInstruction.GREATER_TYPECODE;
   bool typeEquals(other) => other is HGreater;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HGreaterEqual extends HRelational {
   HGreaterEqual(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitGreaterEqual(this);
 
   GreaterEqualOperation get operation => const GreaterEqualOperation();
-  int typeCode() => 22;
+  int typeCode() => HInstruction.GREATER_EQUAL_TYPECODE;
   bool typeEquals(other) => other is HGreaterEqual;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HLess extends HRelational {
   HLess(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitLess(this);
 
   LessOperation get operation => const LessOperation();
-  int typeCode() => 23;
+  int typeCode() => HInstruction.LESS_TYPECODE;
   bool typeEquals(other) => other is HLess;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HLessEqual extends HRelational {
   HLessEqual(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitLessEqual(this);
 
   LessEqualOperation get operation => const LessEqualOperation();
-  int typeCode() => 24;
+  int typeCode() => HInstruction.LESS_EQUAL_TYPECODE;
   bool typeEquals(other) => other is HLessEqual;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HReturn extends HControlFlow {
   HReturn(value) : super(<HInstruction>[value]);
   toString() => 'return';
   accept(HVisitor visitor) => visitor.visitReturn(this);
 }
 
@@ skipping 11 matching lines @@
   void prepareGvn(HTypeMap types) {
     if (!element.isAssignable()) {
       clearAllSideEffects();
       setUseGvn();
     }
   }
   toString() => 'static ${element.name}';
   accept(HVisitor visitor) => visitor.visitStatic(this);
 
   int gvnHashCode() => super.gvnHashCode() ^ element.hashCode();
-  int typeCode() => 25;
+  int typeCode() => HInstruction.STATIC_TYPECODE;
   bool typeEquals(other) => other is HStatic;
   bool dataEquals(HStatic other) => element == other.element;
   bool isCodeMotionInvariant() => !element.isAssignable();
 }
 
 class HStaticStore extends HInstruction {
   Element element;
   HStaticStore(this.element, HInstruction value) : super(<HInstruction>[value]);
   toString() => 'static store ${element.name}';
   accept(HVisitor visitor) => visitor.visitStaticStore(this);
 
-  int typeCode() => 26;
+  int typeCode() => HInstruction.STATIC_STORE_TYPECODE;
   bool typeEquals(other) => other is HStaticStore;
   bool dataEquals(HStaticStore other) => element == other.element;
   bool isStatement(HTypeMap types) => true;
 }
 
 class HLiteralList extends HInstruction {
   HLiteralList(inputs) : super(inputs);
   toString() => 'literal list';
   accept(HVisitor visitor) => visitor.visitLiteralList(this);
 
@@ skipping 120 matching lines @@
   bool get isArgumentTypeCheck => kind == ARGUMENT_TYPE_CHECK;
   bool get isCastTypeCheck => kind == CAST_TYPE_CHECK;
 
   HType get guaranteedType => type;
 
   accept(HVisitor visitor) => visitor.visitTypeConversion(this);
 
   bool isStatement(HTypeMap types) => kind == ARGUMENT_TYPE_CHECK;
   bool isControlFlow() => kind == ARGUMENT_TYPE_CHECK;
 
-  int typeCode() => 28;
+  int typeCode() => HInstruction.TYPE_CONVERSION_TYPECODE;
   bool typeEquals(HInstruction other) => other is HTypeConversion;
   bool dataEquals(HTypeConversion other) {
     return type == other.type && kind == other.kind;
   }
 }
 
 class HStringConcat extends HInstruction {
   final Node node;
   HStringConcat(HInstruction left, HInstruction right, this.node)
       : super(<HInstruction>[left, right]);
@@ skipping 329 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);
 }