Move types out of the HInstructions.

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 713 matching lines @@
   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;
 
   HInstruction(this.inputs)
       : id = idCounter++,
-        usedBy = <HInstruction>[] {
-    if (guaranteedType.isUseful()) propagatedType = guaranteedType;
-  }
+        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); }
 
   static int computeDependsOnFlags(int flags) => flags << FLAG_CHANGES_COUNT;
 
   int getChangesFlags() => flags & ((1 << FLAG_CHANGES_COUNT) - 1);
-  bool hasSideEffects() => getChangesFlags() != 0;
-  void prepareGvn() { setAllSideEffects(); }
+  bool hasSideEffects(HTypeMap types) => getChangesFlags() != 0;
+  void prepareGvn(HTypeMap types) { setAllSideEffects(); }
 
   void setAllSideEffects() { flags |= ((1 << FLAG_CHANGES_COUNT) - 1); }
   void clearAllSideEffects() { flags &= ~((1 << FLAG_CHANGES_COUNT) - 1); }
 
   bool dependsOnSomething() => getFlag(FLAG_DEPENDS_ON_SOMETHING);
   void setDependsOnSomething() { setFlag(FLAG_DEPENDS_ON_SOMETHING); }
 
   bool useGvn() => getFlag(FLAG_USE_GVN);
   void setUseGvn() { setFlag(FLAG_USE_GVN); }
   // Does this node potentially affect control flow.
   bool isControlFlow() => false;
 
   // All isFunctions work on the propagated types.
-  bool isArray() => propagatedType.isArray();
-  bool isReadableArray() => propagatedType.isReadableArray();
-  bool isMutableArray() => propagatedType.isMutableArray();
-  bool isExtendableArray() => propagatedType.isExtendableArray();
-  bool isBoolean() => propagatedType.isBoolean();
-  bool isInteger() => propagatedType.isInteger();
-  bool isDouble() => propagatedType.isDouble();
-  bool isNumber() => propagatedType.isNumber();
-  bool isString() => propagatedType.isString();
-  bool isTypeUnknown() => propagatedType.isUnknown();
-  bool isIndexablePrimitive() => propagatedType.isIndexablePrimitive();
-  bool isPrimitive() => propagatedType.isPrimitive();
-  bool canBePrimitive() => propagatedType.canBePrimitive();
-  bool canBeNull() => propagatedType.canBeNull();
+  bool isArray(HTypeMap types) => types[this].isArray();
+  bool isReadableArray(HTypeMap types) => types[this].isReadableArray();
+  bool isMutableArray(HTypeMap types) => types[this].isMutableArray();
+  bool isExtendableArray(HTypeMap types) => types[this].isExtendableArray();
+  bool isBoolean(HTypeMap types) => types[this].isBoolean();
+  bool isInteger(HTypeMap types) => types[this].isInteger();
+  bool isDouble(HTypeMap types) => types[this].isDouble();
+  bool isNumber(HTypeMap types) => types[this].isNumber();
+  bool isString(HTypeMap types) => types[this].isString();
+  bool isTypeUnknown(HTypeMap types) => types[this].isUnknown();
+  bool isIndexablePrimitive(HTypeMap types)
+      => types[this].isIndexablePrimitive();
+  bool isPrimitive(HTypeMap types) => types[this].isPrimitive();
+  bool canBePrimitive(HTypeMap types) => types[this].canBePrimitive();
+  bool canBeNull(HTypeMap types) => types[this].canBeNull();
 
   /**
    * This is the type the instruction is guaranteed to have. It does not
    * take any propagation into account.
    */
   HType guaranteedType = HType.UNKNOWN;
   bool hasGuaranteedType() => !guaranteedType.isUnknown();
 
   /**
-   * The [propagatedType] is the type the instruction is assumed to have.
-   * Without speculative type assumptions it is computed frome the propagated
-   * type of the instruction's inputs and does not any guess work.
+   * Some instructions have a good idea of their return type, but cannot
+   * guarantee the type. The computed does not need to be more specialized
+   * than the provided type for [this].
    *
-   * With speculative types [computeTypeFromInputTypes()] and [propagatedType]
-   * may differ. In this case the instruction's type must be guarded.
-   *
-   * Note that the [propagatedType] may only be set to [HType.CONFLICTING] with
-   * speculative types (as otherwise the instruction either sets the output
-   * type to [HType.UNKNOWN] or a specific type.
-   */
-  HType propagatedType = HType.UNKNOWN;
-
-  /**
-   * Some instructions have a good idea of their return type, but cannot
-   * guarantee the type. The [likelyType] does not need to be more specialized
-   * than the [propagatedType].
-   *
-   * Examples: the [likelyType] of [:x == y:] is a boolean. In most cases this
+   * Examples: the likely type of [:x == y:] is a boolean. In most cases this
    * cannot be guaranteed, but when merging types we still want to use this
    * information.
    *
    * Similarily the [HAdd] instruction is likely a number. Note that, even if
-   * the [propagatedType] is already set to integer, the [likelyType] still
-   * might just return the number type.
+   * the incoming type is already set to integer, the likely type might still
+   * just return the number type.
    */
-  HType get likelyType() => propagatedType;
+  HType computeLikelyType(HTypeMap types) => types[this];
 
   /**
    * Compute the type of the instruction by propagating the input types through
    * the instruction.
    *
    * By default just copy the guaranteed type.
    */
-  HType computeTypeFromInputTypes() => guaranteedType;
+  HType computeTypeFromInputTypes(HTypeMap types) => guaranteedType;
 
   /**
    * Compute the desired type for the the given [input]. Aside from using
    * other inputs to compute the desired type one should also use
-   * the [propagatedType] which, during the invocation of this method,
+   * the given [types] which, during the invocation of this method,
    * represents the desired type of [this].
    */
-  HType computeDesiredTypeForInput(HInstruction input) => HType.UNKNOWN;
+  HType computeDesiredTypeForInput(HInstruction input, HTypeMap types) {
+    return HType.UNKNOWN;
+  }
 
   bool isInBasicBlock() => block !== null;
 
   String inputsToString() {
     void addAsCommaSeparated(StringBuffer buffer, List<HInstruction> list) {
       for (int i = 0; i < list.length; i++) {
         if (i != 0) buffer.add(', ');
         buffer.add("@${list[i].id}");
       }
     }
@@ skipping 170 matching lines @@
     return validator.isValid;
   }
 
   /**
    * The code for computing a bailout environment, and the code
    * generation must agree on what does not need to be captured,
    * so should always be generated at use site.
    */
   bool isCodeMotionInvariant() => false;
 
-  bool get isStatement() => false;
+  bool isStatement(HTypeMap types) => false;
 }
 
 class HBoolify extends HInstruction {
   HBoolify(HInstruction value) : super(<HInstruction>[value]);
-  void prepareGvn() {
-    assert(!hasSideEffects());
+  void prepareGvn(HTypeMap types) {
+    assert(!hasSideEffects(types));
     setUseGvn();
   }
 
   HType get guaranteedType() => HType.BOOLEAN;
 
   accept(HVisitor visitor) => visitor.visitBoolify(this);
   int typeCode() => 0;
   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.
  */
 abstract class HCheck extends HInstruction {
   HCheck(inputs) : super(inputs);
   HInstruction get checkedInput() => inputs[0];
-  bool get isStatement() => true;
-  void prepareGvn() {
-    assert(!hasSideEffects());
+  bool isStatement(HTypeMap types) => true;
+  void prepareGvn(HTypeMap types) {
+    assert(!hasSideEffects(types));
     setUseGvn();
   }
 }
 
 class HBailoutTarget extends HInstruction {
   final int state;
   bool isEnabled = false;
   HBailoutTarget(this.state) : super(<HInstruction>[]);
-  void prepareGvn() {
-    assert(!hasSideEffects());
+  void prepareGvn(HTypeMap types) {
+    assert(!hasSideEffects(types));
     setUseGvn();
   }
 
   bool isControlFlow() => true;
-  bool get isStatement() => isEnabled;
+  bool isStatement(HTypeMap types) => isEnabled;
 
   accept(HVisitor visitor) => visitor.visitBailoutTarget(this);
   int typeCode() => 29;
   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() {
-    return isEnabled ? guardedType : guarded.propagatedType;
+  HType computeTypeFromInputTypes(HTypeMap types) {
+    return isEnabled ? guardedType : types[guarded];
   }
 
   HType get guaranteedType() => isEnabled ? guardedType : HType.UNKNOWN;
 
   bool isControlFlow() => true;
 
-  bool get isStatement() => isEnabled;
+  bool isStatement(HTypeMap types) => isEnabled;
 
   accept(HVisitor visitor) => visitor.visitTypeGuard(this);
   int typeCode() => 1;
   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;
@@ skipping 39 matching lines @@
   HConditionalBranch(inputs) : super(inputs);
   HInstruction get condition() => inputs[0];
   HBasicBlock get trueBranch() => block.successors[0];
   HBasicBlock get falseBranch() => block.successors[1];
   abstract toString();
 }
 
 class HControlFlow extends HInstruction {
   HControlFlow(inputs) : super(inputs);
   abstract toString();
-  void prepareGvn() {
+  void prepareGvn(HTypeMap types) {
     // Control flow does not have side-effects.
   }
   bool isControlFlow() => true;
-  final bool isStatement = true;
+  bool isStatement(HTypeMap types) => true;
 }
 
 class HInvoke extends HInstruction {
   /**
     * The first argument must be the target: either an [HStatic] node, or
     * the receiver of a method-call. The remaining inputs are the arguments
     * to the invocation.
     */
   HInvoke(List<HInstruction> inputs) : super(inputs);
   static final int ARGUMENTS_OFFSET = 1;
@@ skipping 64 matching lines @@
   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;
   Element get element() => target.element;
   HStatic get target() => inputs[0];
 
-  HType computeDesiredTypeForInput(HInstruction input) {
+  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);
+    return computeDesiredTypeForNonTargetInput(input, types);
   }
 
-  HType computeDesiredTypeForNonTargetInput(HInstruction input) {
+  HType computeDesiredTypeForNonTargetInput(HInstruction input,
+                                            HTypeMap types) {
     return HType.UNKNOWN;
   }
 }
 
 class HInvokeSuper extends HInvokeStatic {
   final bool isSetter;
   HInvokeSuper(inputs, [this.isSetter = false]) : super(inputs);
   toString() => 'invoke super: ${element.name}';
   accept(HVisitor visitor) => visitor.visitInvokeSuper(this);
 
@@ skipping 18 matching lines @@
                       this.setter = false])
       : super(inputs, knownType);
 
   toString() => 'invoke interceptor: ${element.name}';
   accept(HVisitor visitor) => visitor.visitInvokeInterceptor(this);
 
   bool isLengthGetter() {
     return getter && name == const SourceString('length');
   }
 
-  bool isLengthGetterOnStringOrArray() {
-    return isLengthGetter() && inputs[1].isIndexablePrimitive();
+  bool isLengthGetterOnStringOrArray(HTypeMap types) {
+    return isLengthGetter() && inputs[1].isIndexablePrimitive(types);
   }
 
-  HType get likelyType() {
+  HType computeLikelyType(HTypeMap types) {
     // In general a length getter or method returns an int.
     if (name == const SourceString('length')) return HType.INTEGER;
     return HType.UNKNOWN;
   }
 
-  HType computeTypeFromInputTypes() {
-    if (isLengthGetterOnStringOrArray()) return HType.INTEGER;
+  HType computeTypeFromInputTypes(HTypeMap types) {
+    if (isLengthGetterOnStringOrArray(types)) return HType.INTEGER;
     return HType.UNKNOWN;
   }
 
-  HType computeDesiredTypeForNonTargetInput(HInstruction input) {
+  HType computeDesiredTypeForNonTargetInput(HInstruction input,
+                                            HTypeMap types) {
     // If the first argument is a string or an array and we invoke methods
     // on it that mutate it, then we want to restrict the incoming type to be
     // a mutable array.
-    if (input == inputs[1] && input.isIndexablePrimitive()) {
+    if (input == inputs[1] && input.isIndexablePrimitive(types)) {
       if (name == const SourceString('add')
           || name == const SourceString('removeLast')) {
         return HType.MUTABLE_ARRAY;
       }
     }
     return HType.UNKNOWN;
   }
 
-  void prepareGvn() {
-    if (isLengthGetterOnStringOrArray()) {
+  void prepareGvn(HTypeMap types) {
+    if (isLengthGetterOnStringOrArray(types)) {
       setUseGvn();
       clearAllSideEffects();
       setDependsOnSomething();
     } else {
       setAllSideEffects();
     }
   }
 
   int typeCode() => 4;
   bool typeEquals(other) => other is HInvokeInterceptor;
@@ skipping 25 matching lines @@
       : super(name, library, <HInstruction>[receiver]);
 
   HFieldGet.withElement(Element element, HInstruction receiver,
                         [this.isFinalOrConst = false])
       : super.withElement(element, <HInstruction>[receiver]);
 
   HInstruction get receiver() => inputs[0];
 
   accept(HVisitor visitor) => visitor.visitFieldGet(this);
 
-  void prepareGvn() {
+  void prepareGvn(HTypeMap types) {
     setUseGvn();
     clearAllSideEffects();
     if (!isFinalOrConst) setDependsOnSomething();
   }
 
   int typeCode() => 27;
   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)
       : super(name, library, <HInstruction>[receiver, value]);
 
   HFieldSet.withElement(Element element,
                         HInstruction receiver,
                         HInstruction value)
       : super.withElement(element, <HInstruction>[receiver, value]);
 
   HInstruction get receiver() => inputs[0];
   HInstruction get value() => inputs[1];
   accept(HVisitor visitor) => visitor.visitFieldSet(this);
 
-  void prepareGvn() {
+  void prepareGvn(HTypeMap types) {
     // TODO(ngeoffray): implement more fine grained side effects.
     setAllSideEffects();
   }
 
-  final bool isStatement = true;
+  bool isStatement(HTypeMap types) => true;
   String toString() => "FieldSet ${element == null ? fieldName : element}";
 }
 
 class HLocalGet extends HFieldGet {
   HLocalGet(Element element, HLocalValue local)
       : super.withElement(element, local);
 
   accept(HVisitor visitor) => visitor.visitLocalGet(this);
 
   HLocalValue get local() => inputs[0];
 
-  void prepareGvn() {
+  void prepareGvn(HTypeMap types) {
     setUseGvn();
     // TODO(floitsch): if the variable is not captured then it only depends
     // on assignments to the same variable. Otherwise we need to see if the
     // variable is mutated inside closures.
     setDependsOnSomething();
   }
 }
 
 class HLocalSet extends HFieldSet {
   HLocalSet(Element element, HLocalValue local, HInstruction value)
       : super.withElement(element, local, value);
 
   accept(HVisitor visitor) => visitor.visitLocalSet(this);
 
   HLocalValue get local() => inputs[0];
 
-  void prepareGvn() {
+  void prepareGvn(HTypeMap types) {
     // TODO(floitsch): implement more fine grained side effects.
     setAllSideEffects();
   }
 }
 
 class HForeign extends HInstruction {
   final DartString code;
   final HType foreignType;
+  final bool _isStatement;
+
   HForeign(this.code, DartString declaredType, List<HInstruction> inputs)
       : foreignType = computeTypeFromDeclaredType(declaredType),
-        isStatement = false,
+        _isStatement = false,
         super(inputs);
   HForeign.statement(this.code, List<HInstruction> inputs)
       : foreignType = HType.UNKNOWN,
-        isStatement = true,
+        _isStatement = true,
         super(inputs);
   accept(HVisitor visitor) => visitor.visitForeign(this);
 
   static HType computeTypeFromDeclaredType(DartString declaredType) {
     if (declaredType.slowToString() == 'bool') return HType.BOOLEAN;
     if (declaredType.slowToString() == 'int') return HType.INTEGER;
     if (declaredType.slowToString() == 'double') return HType.DOUBLE;
     if (declaredType.slowToString() == 'num') return HType.NUMBER;
     if (declaredType.slowToString() == 'String') return HType.STRING;
     return HType.UNKNOWN;
   }
 
   HType get guaranteedType() => foreignType;
 
-  final bool isStatement;
+  bool isStatement(HTypeMap types) => _isStatement;
 }
 
 class HForeignNew extends HForeign {
   ClassElement element;
   HForeignNew(this.element, List<HInstruction> inputs)
       : super(const LiteralDartString("new"),
               const LiteralDartString("Object"), inputs);
   accept(HVisitor visitor) => visitor.visitForeignNew(this);
 }
 
 class HInvokeBinary extends HInvokeStatic {
   HInvokeBinary(HStatic target, HInstruction left, HInstruction right)
       : super(<HInstruction>[target, left, right]);
 
   HInstruction get left() => inputs[1];
   HInstruction get right() => inputs[2];
 
   abstract BinaryOperation get operation();
-  abstract get builtin();
+  abstract isBuiltin(HTypeMap types);
 }
 
 class HBinaryArithmetic extends HInvokeBinary {
   HBinaryArithmetic(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
 
-  void prepareGvn() {
+  void prepareGvn(HTypeMap types) {
     // An arithmetic expression can take part in global value
     // numbering and do not have any side-effects if we know that all
     // inputs are numbers.
-    if (builtin) {
+    if (isBuiltin(types)) {
       clearAllSideEffects();
       setUseGvn();
     } else {
       setAllSideEffects();
     }
   }
 
-  bool get builtin() => left.isNumber() && right.isNumber();
+  bool isBuiltin(HTypeMap types)
+      => left.isNumber(types) && right.isNumber(types);
 
-  HType computeTypeFromInputTypes() {
-    if (left.isInteger() && right.isInteger()) return HType.INTEGER;
-    if (left.isNumber()) {
-      if (left.isDouble() || right.isDouble()) return HType.DOUBLE;
+  HType computeTypeFromInputTypes(HTypeMap types) {
+    if (left.isInteger(types) && right.isInteger(types)) return HType.INTEGER;
+    if (left.isNumber(types)) {
+      if (left.isDouble(types) || right.isDouble(types)) return HType.DOUBLE;
       return HType.NUMBER;
     }
     return HType.UNKNOWN;
   }
 
-  HType computeDesiredTypeForNonTargetInput(HInstruction input) {
+  HType computeDesiredTypeForNonTargetInput(HInstruction input,
+                                            HTypeMap types) {
+    HType propagatedType = types[this];
     // If the desired output type should be an integer we want to get two
     // integers as arguments.
     if (propagatedType.isInteger()) return HType.INTEGER;
     // If the outgoing type should be a number we can get that if both inputs
     // are numbers. If we don't know the outgoing type we try to make it a
     // number.
     if (propagatedType.isUnknown() || propagatedType.isNumber()) {
       return HType.NUMBER;
     }
     // Even if the desired outgoing type is not a number we still want the
     // second argument to be a number if the first one is a number. This will
     // not help for the outgoing type, but at least the binary arithmetic
     // operation will not have type problems.
     // TODO(floitsch): normally we shouldn't request a number, but simply
     // throw an IllegalArgumentException if it isn't. This would be similar
     // to the array case.
-    if (input == right && left.isNumber()) return HType.NUMBER;
+    if (input == right && left.isNumber(types)) return HType.NUMBER;
     return HType.UNKNOWN;
   }
 
-  HType get likelyType() {
-    if (left.isTypeUnknown()) return HType.NUMBER;
+  HType computeLikelyType(HTypeMap types) {
+    if (left.isTypeUnknown(types)) return HType.NUMBER;
     return HType.UNKNOWN;
   }
 
   // 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;
   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() {
-    if (left.isNumber()) return HType.DOUBLE;
+  HType computeTypeFromInputTypes(HTypeMap types) {
+    if (left.isNumber(types)) return HType.DOUBLE;
     return HType.UNKNOWN;
   }
 
-  HType computeDesiredTypeForNonTargetInput(HInstruction input) {
+  HType computeDesiredTypeForNonTargetInput(HInstruction input,
+                                            HTypeMap types) {
     // A division can never return an integer. So don't ask for integer inputs.
-    if (propagatedType.isInteger()) return HType.UNKNOWN;
-    return super.computeDesiredTypeForNonTargetInput(input);
+    if (isInteger(types)) return HType.UNKNOWN;
+    return super.computeDesiredTypeForNonTargetInput(input, types);
   }
 
   DivideOperation get operation() => const DivideOperation();
   int typeCode() => 6;
   bool typeEquals(other) => other is HDivide;
   bool dataEquals(HInstruction other) => true;
 }
 
 class HModulo extends HBinaryArithmetic {
   HModulo(HStatic target, HInstruction left, HInstruction right)
@@ skipping 63 matching lines @@
   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);
 
-  HType computeTypeFromInputTypes() {
+  HType computeTypeFromInputTypes(HTypeMap types) {
     // All bitwise operations on primitive types either produce an
     // integer or throw an error.
-    if (left.isPrimitive()) return HType.INTEGER;
+    if (left.isPrimitive(types)) return HType.INTEGER;
     return HType.UNKNOWN;
   }
 
-  HType computeDesiredTypeForNonTargetInput(HInstruction input) {
+  HType computeDesiredTypeForNonTargetInput(HInstruction input,
+                                            HTypeMap types) {
+    HType propagatedType = types[this];
     // If the outgoing type should be a number we can get that only if both
     // inputs are integers. If we don't know the outgoing type we try to make
     // it an integer.
     if (propagatedType.isUnknown() || propagatedType.isNumber()) {
       return HType.INTEGER;
     }
     return HType.UNKNOWN;
   }
 
-  HType get likelyType() {
-    if (left.isTypeUnknown()) return HType.INTEGER;
+  HType computeLikelyType(HTypeMap types) {
+    if (left.isTypeUnknown(types)) return HType.INTEGER;
     return HType.UNKNOWN;
   }
 
   // TODO(floitsch): make class abstract instead of adding an abstract method.
   abstract accept(HVisitor visitor);
 }
 
 class HShiftLeft extends HBinaryBitOp {
   HShiftLeft(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitShiftLeft(this);
 
   // Shift left cannot be mapped to the native operator unless the
   // shift count is guaranteed to be an integer in the [0,31] range.
-  bool get builtin() {
-    if (!left.isNumber() || !right.isConstantInteger()) return false;
+  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;
   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 get builtin() => false;
+  bool isBuiltin(HTypeMap types) => false;
 
   ShiftRightOperation get operation() => const ShiftRightOperation();
   int typeCode() => 12;
   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);
@@ skipping 26 matching lines @@
   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];
 
-  void prepareGvn() {
+  void prepareGvn(HTypeMap types) {
     // A unary arithmetic expression can take part in global value
     // numbering and does not have any side-effects if its input is a
     // number.
-    if (builtin) {
+    if (isBuiltin(types)) {
       clearAllSideEffects();
       setUseGvn();
     } else {
       setAllSideEffects();
     }
   }
 
-  bool get builtin() => operand.isNumber();
+  bool isBuiltin(HTypeMap types) => operand.isNumber(types);
 
-  HType computeTypeFromInputTypes() {
-    HType operandType = operand.propagatedType;
+  HType computeTypeFromInputTypes(HTypeMap types) {
+    HType operandType = types[operand];
     if (operandType.isNumber()) return operandType;
     return HType.UNKNOWN;
   }
 
-  HType computeDesiredTypeForNonTargetInput(HInstruction input) {
+  HType computeDesiredTypeForNonTargetInput(HInstruction input,
+                                            HTypeMap types) {
+    HType propagatedType = types[this];
     // If the outgoing type should be a number (integer, double or both) we
     // want the outgoing type to be the input too.
     // If we don't know the outgoing type we try to make it a number.
     if (propagatedType.isNumber()) return propagatedType;
     if (propagatedType.isUnknown()) return HType.NUMBER;
     return HType.UNKNOWN;
   }
 
-  HType get likelyType() => HType.NUMBER;
+  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;
   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() {
+  HType computeTypeFromInputTypes(HTypeMap types) {
     // All bitwise operations on primitive types either produce an
     // integer or throw an error.
-    if (operand.isPrimitive()) return HType.INTEGER;
+    if (operand.isPrimitive(types)) return HType.INTEGER;
     return HType.UNKNOWN;
   }
 
-  HType computeDesiredTypeForNonTargetInput(HInstruction input) {
+  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;
@@ skipping 78 matching lines @@
     return kind === DO_WHILE_LOOP;
   }
 }
 
 class HConstant extends HInstruction {
   final Constant constant;
   final HType constantType;
   HConstant.internal(this.constant, HType this.constantType)
       : super(<HInstruction>[]);
 
-  void prepareGvn() {
-    assert(!hasSideEffects());
+  void prepareGvn(HTypeMap types) {
+    assert(!hasSideEffects(types));
   }
 
   toString() => 'literal: $constant';
   accept(HVisitor visitor) => visitor.visitConstant(this);
 
   HType get guaranteedType() => constantType;
 
   bool isConstant() => true;
   bool isConstantBoolean() => constant.isBool();
   bool isConstantNull() => constant.isNull();
   bool isConstantNumber() => constant.isNum();
   bool isConstantInteger() => constant.isInt();
   bool isConstantString() => constant.isString();
   bool isConstantList() => constant.isList();
   bool isConstantMap() => constant.isMap();
   bool isConstantFalse() => constant.isFalse();
   bool isConstantTrue() => constant.isTrue();
 
   // Maybe avoid this if the literal is big?
   bool isCodeMotionInvariant() => true;
 }
 
 class HNot extends HInstruction {
   HNot(HInstruction value) : super(<HInstruction>[value]);
-  void prepareGvn() {
-    assert(!hasSideEffects());
+  void prepareGvn(HTypeMap types) {
+    assert(!hasSideEffects(types));
     setUseGvn();
   }
 
   HType get guaranteedType() => HType.BOOLEAN;
 
   // 'Not' only works on booleans. That's what we want as input.
-  HType computeDesiredTypeForInput(HInstruction input) => HType.BOOLEAN;
+  HType computeDesiredTypeForInput(HInstruction input, HTypeMap types) {
+    return HType.BOOLEAN;
+  }
 
   accept(HVisitor visitor) => visitor.visitNot(this);
   int typeCode() => 18;
   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 {
   HLocalValue(Element element) : super(<HInstruction>[]) {
     sourceElement = element;
   }
 
-  void prepareGvn() {
-    assert(!hasSideEffects());
+  void prepareGvn(HTypeMap types) {
+    assert(!hasSideEffects(types));
   }
   toString() => 'local ${sourceElement.name}';
   accept(HVisitor visitor) => visitor.visitLocalValue(this);
   bool isCodeMotionInvariant() => true;
 }
 
 class HParameterValue extends HLocalValue {
   HParameterValue(Element element) : super(element);
 
   toString() => 'parameter ${sourceElement.name.slowToString()}';
@@ skipping 30 matching lines @@
   void addInput(HInstruction input) {
     assert(isInBasicBlock());
     inputs.add(input);
     input.usedBy.add(this);
   }
 
   // Compute the (shared) type of the inputs if any. If all inputs
   // have the same known type return it. If any two inputs have
   // different known types, we'll return a conflict -- otherwise we'll
   // simply return an unknown type.
-  HType computeInputsType(bool ignoreUnknowns) {
+  HType computeInputsType(bool ignoreUnknowns, HTypeMap types) {
     HType candidateType = HType.CONFLICTING;
     for (int i = 0, length = inputs.length; i < length; i++) {
-      HType inputType = inputs[i].propagatedType;
+      HType inputType = types[inputs[i]];
       if (ignoreUnknowns && inputType.isUnknown()) continue;
       // Phis need to combine the incoming types using the union operation.
       // For example, if one incoming edge has type integer and the other has
       // type double, then the phi is either an integer or double and thus has
       // type number.
       candidateType = candidateType.union(inputType);
       if (candidateType.isUnknown()) return HType.UNKNOWN;
     }
     return candidateType;
   }
 
-  HType computeTypeFromInputTypes() {
-    HType inputsType = computeInputsType(false);
+  HType computeTypeFromInputTypes(HTypeMap types) {
+    HType inputsType = computeInputsType(false, types);
     if (inputsType.isConflicting()) return HType.UNKNOWN;
     return inputsType;
   }
 
-  HType computeDesiredTypeForInput(HInstruction input) {
+  HType computeDesiredTypeForInput(HInstruction input, HTypeMap types) {
+    HType propagatedType = types[this];
     // Best case scenario for a phi is, when all inputs have the same type. If
     // there is no desired outgoing type we therefore try to unify the input
     // types (which is basically the [likelyType]).
-    if (propagatedType.isUnknown()) return likelyType;
+    if (propagatedType.isUnknown()) return computeLikelyType(types);
     // When the desired outgoing type is conflicting we don't need to give any
     // requirements on the inputs.
     if (propagatedType.isConflicting()) return HType.UNKNOWN;
     // Otherwise the input type must match the desired outgoing type.
     return propagatedType;
   }
 
-  HType get likelyType() {
-    HType agreedType = computeInputsType(true);
+  HType computeLikelyType(HTypeMap types) {
+    HType agreedType = computeInputsType(true, types);
     if (agreedType.isConflicting()) return HType.UNKNOWN;
     // Don't be too restrictive. If the agreed type is integer or double just
     // say that the likely type is number. If more is expected the type will be
     // propagated back.
     if (agreedType.isNumber()) return HType.NUMBER;
     return agreedType;
   }
 
   bool isLogicalOperator() => logicalOperatorType != IS_NOT_LOGICAL_OPERATOR;
 
   String logicalOperator() {
     assert(isLogicalOperator());
     if (logicalOperatorType == IS_AND) return "&&";
     assert(logicalOperatorType == IS_OR);
     return "||";
   }
 
   toString() => 'phi';
   accept(HVisitor visitor) => visitor.visitPhi(this);
 }
 
 class HRelational extends HInvokeBinary {
   bool usesBoolifiedInterceptor = false;
   HRelational(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
 
-  void prepareGvn() {
+  void prepareGvn(HTypeMap types) {
     // Relational expressions can take part in global value numbering
     // and do not have any side-effects if we know all the inputs are
     // numbers. This can be improved for at least equality.
-    if (builtin) {
+    if (isBuiltin(types)) {
       clearAllSideEffects();
       setUseGvn();
     } else {
       setAllSideEffects();
     }
   }
 
-  HType computeTypeFromInputTypes() {
-    if (left.isNumber() || usesBoolifiedInterceptor) return HType.BOOLEAN;
+  HType computeTypeFromInputTypes(HTypeMap types) {
+    if (left.isNumber(types) || usesBoolifiedInterceptor) return HType.BOOLEAN;
     return HType.UNKNOWN;
   }
 
   HType get guaranteedType() {
     if (usesBoolifiedInterceptor) return HType.BOOLEAN;
     return HType.UNKNOWN;
   }
 
-  HType computeDesiredTypeForNonTargetInput(HInstruction input) {
+  HType computeDesiredTypeForNonTargetInput(HInstruction input,
+                                            HTypeMap types) {
+    HType propagatedType = types[this];
     // For all relational operations exept HEquals, we expect to get numbers
     // only. With numbers the outgoing type is a boolean. If something else
     // is desired, then numbers are incorrect, though.
     if (propagatedType.isUnknown() || propagatedType.isBoolean()) {
-      if (left.isTypeUnknown() || left.isNumber()) {
+      if (left.isTypeUnknown(types) || left.isNumber(types)) {
         return HType.NUMBER;
       }
     }
     return HType.UNKNOWN;
   }
 
-  HType get likelyType() => HType.BOOLEAN;
+  HType computeLikelyType(HTypeMap types) => HType.BOOLEAN;
 
-  bool get builtin() => left.isNumber() && right.isNumber();
+  bool isBuiltin(HTypeMap types)
+      => left.isNumber(types) && right.isNumber(types);
   // TODO(1603): the class should be marked as abstract.
   abstract BinaryOperation get operation();
 }
 
 class HEquals extends HRelational {
   HEquals(HStatic target, HInstruction left, HInstruction right)
       : super(target, left, right);
   accept(HVisitor visitor) => visitor.visitEquals(this);
 
-  bool get builtin() {
+  bool isBuiltin(HTypeMap types) {
     // All primitive types have === semantics.
     // Note that this includes all constants except the user-constructed
     // objects.
-    return left.propagatedType.isPrimitive() ||
+    return types[left].isPrimitive() ||
         left.isConstantNull() ||
         right.isConstantNull();
   }
 
-  HType computeTypeFromInputTypes() {
-    if (builtin || usesBoolifiedInterceptor) return HType.BOOLEAN;
+  HType computeTypeFromInputTypes(HTypeMap types) {
+    if (isBuiltin(types) || usesBoolifiedInterceptor) return HType.BOOLEAN;
     return HType.UNKNOWN;
   }
 
-  HType computeDesiredTypeForNonTargetInput(HInstruction input) {
-    if (input == left && right.propagatedType.isUseful()) {
+  HType computeDesiredTypeForNonTargetInput(HInstruction input,
+                                            HTypeMap types) {
+    HType propagatedType = types[this];
+    if (input == left && types[right].isUseful()) {
       // All our useful types have === semantics. But we don't want to
       // speculatively test for all possible types. Therefore we try to match
       // the two types. That is, if we see x == 3, then we speculatively test
       // if x is a number and bailout if it isn't.
       // If right is a number we don't need more than a number (no need to match
       // the exact type of right).
-      if (right.isNumber()) return HType.NUMBER;
+      if (right.isNumber(types)) return HType.NUMBER;
       // String equality testing is much more common than array equality
       // testing.
-      if (right.isIndexablePrimitive()) return HType.STRING;
-      return right.propagatedType;
+      if (right.isIndexablePrimitive(types)) return HType.STRING;
+      return types[right];
     }
     // String equality testing is much more common than array equality testing.
-    if (input == left && left.isIndexablePrimitive()) {
+    if (input == left && left.isIndexablePrimitive(types)) {
       return HType.READABLE_ARRAY;
     }
     // String equality testing is much more common than array equality testing.
-    if (input == right && right.isIndexablePrimitive()) {
+    if (input == right && right.isIndexablePrimitive(types)) {
       return HType.STRING;
     }
     return HType.UNKNOWN;
   }
 
   EqualsOperation get operation() => const EqualsOperation();
   int typeCode() => 19;
   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 get builtin() => true;
+  bool isBuiltin(HTypeMap types) => true;
 
   HType get guaranteedType() => HType.BOOLEAN;
-  HType computeTypeFromInputTypes() => 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) => HType.UNKNOWN;
+  HType computeDesiredTypeForInput(HInstruction input, HTypeMap types)
+      => HType.UNKNOWN;
 
   IdentityOperation get operation() => const IdentityOperation();
   int typeCode() => 20;
   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);
@@ skipping 48 matching lines @@
   final bool isRethrow;
   HThrow(value, [this.isRethrow = false]) : super(<HInstruction>[value]);
   toString() => 'throw';
   accept(HVisitor visitor) => visitor.visitThrow(this);
 }
 
 class HStatic extends HInstruction {
   final Element element;
   HStatic(this.element) : super(<HInstruction>[]) { assert(element !== null); }
 
-  void prepareGvn() {
+  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;
   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;
   bool typeEquals(other) => other is HStaticStore;
   bool dataEquals(HStaticStore other) => element == other.element;
-  final bool isStatement = true;
+  bool isStatement(HTypeMap types) => true;
 }
 
 class HLiteralList extends HInstruction {
   HLiteralList(inputs) : super(inputs);
   toString() => 'literal list';
   accept(HVisitor visitor) => visitor.visitLiteralList(this);
 
   HType get guaranteedType() => HType.MUTABLE_ARRAY;
 
-  void prepareGvn() {
-    assert(!hasSideEffects());
+  void prepareGvn(HTypeMap types) {
+    assert(!hasSideEffects(types));
   }
 }
 
 class HIndex extends HInvokeStatic {
   HIndex(HStatic target, HInstruction receiver, HInstruction index)
       : super(<HInstruction>[target, receiver, index]);
   toString() => 'index operator';
   accept(HVisitor visitor) => visitor.visitIndex(this);
 
-  void prepareGvn() {
-    if (builtin) {
+  void prepareGvn(HTypeMap types) {
+    if (isBuiltin(types)) {
       clearAllSideEffects();
     } else {
       setAllSideEffects();
     }
   }
 
   HInstruction get receiver() => inputs[1];
   HInstruction get index() => inputs[2];
 
-  HType computeDesiredTypeForNonTargetInput(HInstruction input) {
-    if (input == receiver && (index.isTypeUnknown() || index.isNumber())) {
+  HType computeDesiredTypeForNonTargetInput(HInstruction input,
+                                            HTypeMap types) {
+    if (input == receiver &&
+        (index.isTypeUnknown(types) || index.isNumber(types))) {
       return HType.INDEXABLE_PRIMITIVE;
     }
     // The index should be an int when the receiver is a string or array.
     // However it turns out that inserting an integer check in the optimized
     // version is cheaper than having another bailout case. This is true,
     // because the integer check will simply throw if it fails.
     return HType.UNKNOWN;
   }
 
-  bool get builtin() => receiver.isIndexablePrimitive() && index.isInteger();
+  bool isBuiltin(HTypeMap types)
+      => receiver.isIndexablePrimitive(types) && index.isInteger(types);
 }
 
 class HIndexAssign extends HInvokeStatic {
   HIndexAssign(HStatic target,
                HInstruction receiver,
                HInstruction index,
                HInstruction value)
       : super(<HInstruction>[target, receiver, index, value]);
   toString() => 'index assign operator';
   accept(HVisitor visitor) => visitor.visitIndexAssign(this);
 
   HInstruction get receiver() => inputs[1];
   HInstruction get index() => inputs[2];
   HInstruction get value() => inputs[3];
 
   // Note, that we don't have a computeTypeFromInputTypes, since [HIndexAssign]
   // is never used as input.
 
-  HType computeDesiredTypeForNonTargetInput(HInstruction input) {
-    if (input == receiver && (index.isTypeUnknown() || index.isNumber())) {
+  HType computeDesiredTypeForNonTargetInput(HInstruction input,
+                                            HTypeMap types) {
+    if (input == receiver &&
+        (index.isTypeUnknown(types) || index.isNumber(types))) {
       return HType.MUTABLE_ARRAY;
     }
     // The index should be an int when the receiver is a string or array.
     // However it turns out that inserting an integer check in the optimized
     // version is cheaper than having another bailout case. This is true,
     // because the integer check will simply throw if it fails.
     return HType.UNKNOWN;
   }
 
-  bool get builtin() => receiver.isMutableArray() && index.isInteger();
-  bool get isStatement() => !builtin;
+  bool isBuiltin(HTypeMap types)
+      => receiver.isMutableArray(types) && index.isInteger(types);
+  bool isStatement(HTypeMap types) => !isBuiltin(types);
 }
 
 class HIs extends HInstruction {
   final Type typeExpression;
   final bool nullOk;
 
   HIs.withTypeInfoCall(this.typeExpression, HInstruction expression,
                        HInstruction typeInfo, [this.nullOk = false])
     : super(<HInstruction>[expression, typeInfo]);
 
@@ skipping 34 matching lines @@
 
   bool get isChecked() => kind != NO_CHECK;
   bool get isCheckedModeCheck() => kind == CHECKED_MODE_CHECK;
   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 get isStatement() => kind == ARGUMENT_TYPE_CHECK;
+  bool isStatement(HTypeMap types) => kind == ARGUMENT_TYPE_CHECK;
   bool isControlFlow() => kind == ARGUMENT_TYPE_CHECK;
 
   int typeCode() => 28;
   bool typeEquals(HInstruction other) => other is HTypeConversion;
   bool dataEquals(HTypeConversion other) {
     return type == other.type && kind == other.kind;
   }
 }
 
 class HStringConcat extends HInstruction {
@@ skipping 332 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);
 }