Move types out of the HInstructions.

lib/compiler/implementation/ssa/codegen.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.
 
 class SsaCodeGeneratorTask extends CompilerTask {
   final JavaScriptBackend backend;
   SsaCodeGeneratorTask(JavaScriptBackend backend)
       : this.backend = backend,
         super(backend.compiler);
   String get name() => 'SSA code generator';
@@ skipping 136 matching lines @@
    * - [TYPE_DECLARATION] means that the graph can be generated as an
    * expression, and that it only generates expressions of the form
    *   variable = expression
    * which are also valid as parts of a "var" declaration.
    */
   static final int TYPE_STATEMENT = 0;
   static final int TYPE_EXPRESSION = 1;
   static final int TYPE_DECLARATION = 2;
 
   final JavaScriptBackend backend;
-  final WorkItem work;
+  final JavaScriptWorkItem work;
   final CodeBuffer buffer;
   final String parameters;
 
   final Set<HInstruction> generateAtUseSite;
   final Set<HInstruction> controlFlowOperators;
   final Map<Element, ElementAction> breakAction;
   final Map<Element, ElementAction> continueAction;
   final Map<Element, String> parameterNames;
 
   /**
@@ skipping 124 matching lines @@
   void withPrecedence(int precedence, void action()) {
     int oldPrecedence = expectedPrecedence;
     beginExpression(precedence);
     expectedPrecedence = precedence;
     action();
     expectedPrecedence = oldPrecedence;
     endExpression(precedence);
   }
 
   void preGenerateMethod(HGraph graph) {
-    new SsaInstructionMerger(generateAtUseSite).visitGraph(graph);
-    new SsaConditionMerger(generateAtUseSite,
-                           controlFlowOperators).visitGraph(graph);
+    new SsaInstructionMerger(work, generateAtUseSite).visitGraph(graph);
+    new SsaConditionMerger(
+        work, generateAtUseSite, controlFlowOperators).visitGraph(graph);
     SsaLiveIntervalBuilder intervalBuilder =
         new SsaLiveIntervalBuilder(compiler, generateAtUseSite);
     intervalBuilder.visitGraph(graph);
     SsaVariableAllocator allocator = new SsaVariableAllocator(
         compiler,
         intervalBuilder.liveInstructions,
         intervalBuilder.liveIntervals,
         generateAtUseSite,
         parameterNames);
     allocator.visitGraph(graph);
@@ skipping 241 matching lines @@
 
     // Check that the operation is one of +, *, - or /. Record whether
     // or not the operation is commutative.
     var isCommutative = false;
     if (instruction is HAdd || instruction is HMultiply) {
       isCommutative = true;
     } else if (instruction is !HSubtract && instruction is !HDivide) {
       return false;
     }
 
+    HTypeMap types = work.types;
+
     // Is it a builtin operation involving +, -, /, or *?
     HBinaryArithmetic binaryInstruction = instruction;
     assert(binaryInstruction.inputs.length == 3);
-    if (binaryInstruction.builtin) {
+    if (binaryInstruction.isBuiltin(types)) {
       var left = binaryInstruction.left;
       var right = binaryInstruction.right;
       if (isCommutative && variableNames.getName(right) == name) {
         var tmp = right;
         right = left;
         left = tmp;
       }
 
       // Check that left has the same name as the definition and emit
       // the short update definition if it is.
@@ skipping 598 matching lines @@
       instruction = instruction.next;
     }
     assignPhisOfSuccessors(node);
     if (instruction is HLoopBranch && isGeneratingExpression()) {
       addExpressionSeparator();
     }
     visit(instruction, JSPrecedence.STATEMENT_PRECEDENCE);
   }
 
   visitInvokeBinary(HInvokeBinary node, String op) {
-    if (node.builtin) {
+    if (node.isBuiltin(work.types)) {
       JSBinaryOperatorPrecedence operatorPrecedences = JSPrecedence.binary[op];
       beginExpression(operatorPrecedences.precedence);
       use(node.left, operatorPrecedences.left);
       buffer.add(' $op ');
       use(node.right, operatorPrecedences.right);
       endExpression(operatorPrecedences.precedence);
     } else {
       visitInvokeStatic(node);
     }
   }
 
   // We want the outcome of bit-operations to be positive. We use the unsigned
   // shift operator to achieve this.
   visitBitInvokeBinary(HBinaryBitOp node, String op) {
-    if (node.builtin && requiresUintConversion(node)) {
+    HTypeMap types = work.types;
+    if (node.isBuiltin(types) && requiresUintConversion(node)) {
       beginExpression(unsignedShiftPrecedences.precedence);
       int oldPrecedence = this.expectedPrecedence;
       this.expectedPrecedence = JSPrecedence.SHIFT_PRECEDENCE;
       visitInvokeBinary(node, op);
       buffer.add(' >>> 0');
       this.expectedPrecedence = oldPrecedence;
       endExpression(unsignedShiftPrecedences.precedence);
     } else {
       visitInvokeBinary(node, op);
     }
   }
 
   visitInvokeUnary(HInvokeUnary node, String op) {
-    if (node.builtin) {
+    if (node.isBuiltin(work.types)) {
       beginExpression(JSPrecedence.PREFIX_PRECEDENCE);
       buffer.add('$op');
       use(node.operand, JSPrecedence.PREFIX_PRECEDENCE);
       endExpression(JSPrecedence.PREFIX_PRECEDENCE);
     } else {
       visitInvokeStatic(node);
     }
   }
 
   // We want the outcome of bit-operations to be positive. We use the unsigned
   // shift operator to achieve this.
   visitBitInvokeUnary(HInvokeUnary node, String op) {
-    if (node.builtin && requiresUintConversion(node)) {
+    HTypeMap types = work.types;
+    if (node.isBuiltin(types) && requiresUintConversion(node)) {
       beginExpression(unsignedShiftPrecedences.precedence);
       int oldPrecedence = this.expectedPrecedence;
       this.expectedPrecedence = JSPrecedence.SHIFT_PRECEDENCE;
       visitInvokeUnary(node, op);
       buffer.add(' >>> 0');
       this.expectedPrecedence = oldPrecedence;
       endExpression(unsignedShiftPrecedences.precedence);
     } else {
       visitInvokeUnary(node, op);
     }
   }
 
   void emitIdentityComparison(HInstruction left, HInstruction right) {
-    String op = singleIdentityComparison(left, right);
+    String op = singleIdentityComparison(left, right, work.types);
     if (op != null) {
       beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
       use(left, JSPrecedence.EQUALITY_PRECEDENCE);
       buffer.add(' $op ');
       use(right, JSPrecedence.RELATIONAL_PRECEDENCE);
       endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
     } else {
       assert(NullConstant.JsNull == 'null');
       withPrecedence(JSPrecedence.CONDITIONAL_PRECEDENCE, () {
         beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
@@ skipping 12 matching lines @@
           use(left, JSPrecedence.EQUALITY_PRECEDENCE);
           buffer.add(' === ');
           use(right, JSPrecedence.EQUALITY_PRECEDENCE);
           endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
         });
       });
     }
   }
 
   visitEquals(HEquals node) {
-    if (node.builtin) {
+    if (node.isBuiltin(work.types)) {
       emitIdentityComparison(node.left, node.right);
     } else {
       visitInvokeStatic(node);
     }
   }
 
   visitIdentity(HIdentity node) {
-    assert(node.builtin);
+    assert(node.isBuiltin(work.types));
     emitIdentityComparison(node.left, node.right);
   }
 
   visitAdd(HAdd node)               => visitInvokeBinary(node, '+');
   visitDivide(HDivide node)         => visitInvokeBinary(node, '/');
   visitMultiply(HMultiply node)     => visitInvokeBinary(node, '*');
   visitSubtract(HSubtract node)     => visitInvokeBinary(node, '-');
   // Truncating divide does not have a JS equivalent.
   visitTruncatingDivide(HTruncatingDivide node) => visitInvokeStatic(node);
   // Modulo cannot be mapped to the native operator (different semantics).
@@ skipping 129 matching lines @@
     // all blocks.
     if (start !== end) return MULTIPLE_STATEMENTS;
 
     int kind = EMPTY;
     bool updateKind(int newKind) {
       if (kind != EMPTY) return false;
       kind = newKind;
       return true;
     }
 
+    HTypeMap types = work.types;
+
     for (HInstruction instruction = start.first;
          instruction != start.last;
          instruction = instruction.next) {
-      if (instruction.isStatement) {
+      if (instruction.isStatement(types)) {
         if (!updateKind(ONE_STATEMENT)) return MULTIPLE_STATEMENTS;
       } else if (!isGenerateAtUseSite(instruction)) {
         if (!updateKind(ONE_EXPRESSION)) return MULTIPLE_STATEMENTS;
       }
     }
 
     HInstruction last = start.last;
     if (last is !HGoto) {
-      if (!updateKind(last.isStatement ? ONE_STATEMENT : ONE_EXPRESSION)) {
+      if (!updateKind(last.isStatement(types)
+                      ? ONE_STATEMENT
+                      : ONE_EXPRESSION)) {
         return MULTIPLE_STATEMENTS;
       }
     }
 
     CopyHandler handler = variableNames.getCopyHandler(start);
     if (handler !== null && !handler.isEmpty()) {
       if (handler.assignments.length > 1) return MULTIPLE_STATEMENTS;
       if (handler.assignments.length == 1) {
         if (!updateKind(ONE_STATEMENT)) return MULTIPLE_STATEMENTS;
       }
@@ skipping 283 matching lines @@
       } else {
         Selector selector = getOptimizedSelectorFor(node, node.selector);
         world.registerDynamicInvocation(node.name, selector);
         if (inLoop) backend.builder.selectorsCalledInLoop[node.name] = selector;
       }
     }
     endExpression(JSPrecedence.CALL_PRECEDENCE);
   }
 
   Selector getOptimizedSelectorFor(HInvoke node, Selector defaultSelector) {
-    Type receiverType = node.inputs[0].propagatedType.computeType(compiler);
+    HType receiverHType = work.types[node.inputs[0]];
+    Type receiverType = receiverHType.computeType(compiler);
     if (receiverType !== null) {
       return new TypedSelector(receiverType, defaultSelector);
     } else {
       return defaultSelector;
     }
   }
 
   visitInvokeDynamicSetter(HInvokeDynamicSetter node) {
     beginExpression(JSPrecedence.CALL_PRECEDENCE);
     use(node.receiver, JSPrecedence.MEMBER_PRECEDENCE);
@@ skipping 68 matching lines @@
     world.registerStaticUse(superMethod);
   }
 
   visitFieldGet(HFieldGet node) {
     String name = compiler.namer.getName(node.element);
     beginExpression(JSPrecedence.MEMBER_PRECEDENCE);
     use(node.receiver, JSPrecedence.MEMBER_PRECEDENCE);
     buffer.add('.');
     buffer.add(name);
     beginExpression(JSPrecedence.MEMBER_PRECEDENCE);
-    Type type = node.receiver.propagatedType.computeType(compiler);
+    HType receiverHType = work.types[node.receiver];
+    Type type = receiverHType.computeType(compiler);
     if (type != null) {
       world.registerFieldGetter(node.element.name, type);
     }
   }
 
   // Determine if an instruction is a simple number computation
   // involving only things with guaranteed number types and a given
   // field.
   bool isSimpleFieldNumberComputation(HInstruction value, HFieldSet node) {
     if (value.guaranteedType.union(HType.NUMBER) == HType.NUMBER) return true;
@@ skipping 11 matching lines @@
         node.value.hasGuaranteedType() &&
         node.block.dominates(currentGraph.exit)) {
       backend.updateFieldConstructorSetters(node.element,
                                             node.value.guaranteedType);
     }
     String name = compiler.namer.getName(node.element);
     beginExpression(JSPrecedence.ASSIGNMENT_PRECEDENCE);
     use(node.receiver, JSPrecedence.MEMBER_PRECEDENCE);
     buffer.add('.');
     buffer.add(name);
-    Type type = node.receiver.propagatedType.computeType(compiler);
+    HTypeMap types = work.types;
+    Type type = types[node.receiver].computeType(compiler);
     if (type != null) {
       if (!work.element.isGenerativeConstructorBody()) {
         world.registerFieldSetter(node.element.name, type);
       }
       // Determine the types seen so far for the field. If only number
       // types have been seen and the value of the field set is a
       // simple number computation only depending on that field, we
       // can safely keep the number type for the field.
       HType fieldSettersType = backend.fieldSettersTypeSoFar(node.element);
       HType initializersType = backend.typeFromInitializersSoFar(node.element);
       HType fieldType = fieldSettersType.union(initializersType);
       if (HType.NUMBER.union(fieldType) == HType.NUMBER &&
           isSimpleFieldNumberComputation(node.value, node)) {
         backend.updateFieldSetters(node.element, HType.NUMBER);
       } else {
-        backend.updateFieldSetters(node.element,
-                                   node.value.propagatedType);
+        backend.updateFieldSetters(node.element, types[node.value]);
       }
     }
     buffer.add(' = ');
     use(node.value, JSPrecedence.ASSIGNMENT_PRECEDENCE);
     endExpression(JSPrecedence.ASSIGNMENT_PRECEDENCE);
   }
 
   visitLocalGet(HLocalGet node) {
     use(node.receiver, JSPrecedence.EXPRESSION_PRECEDENCE);
   }
@@ skipping 15 matching lines @@
     beginExpression(JSPrecedence.EXPRESSION_PRECEDENCE);
     buffer.add(parts[0]);
     for (int i = 0; i < inputs.length; i++) {
       use(inputs[i], JSPrecedence.EXPRESSION_PRECEDENCE);
       buffer.add(parts[i + 1]);
     }
     endExpression(JSPrecedence.EXPRESSION_PRECEDENCE);
   }
 
   visitForeignNew(HForeignNew node) {
+    HTypeMap types = work.types;
     int j = 0;
     node.element.forEachInstanceField(
       includeBackendMembers: true,
       includeSuperMembers: true,
       f: (ClassElement enclosingClass, Element member) {
-        backend.updateFieldInitializers(member,
-                                        node.inputs[j].propagatedType);
+        backend.updateFieldInitializers(member, types[node.inputs[j]]);
         j++;
       });
     String jsClassReference = compiler.namer.isolateAccess(node.element);
     beginExpression(JSPrecedence.MEMBER_PRECEDENCE);
     buffer.add('new $jsClassReference(');
     // We can't use 'visitArguments', since our arguments start at input[0].
     List<HInstruction> inputs = node.inputs;
     for (int i = 0; i < inputs.length; i++) {
       if (i != 0) buffer.add(', ');
       use(inputs[i], JSPrecedence.ASSIGNMENT_PRECEDENCE);
@@ skipping 69 matching lines @@
     }
   }
 
   visitNot(HNot node) {
     assert(node.inputs.length == 1);
     generateNot(node.inputs[0]);
   }
 
 
   void generateNot(HInstruction input) {
+    HTypeMap types = work.types;
+
     bool isBuiltinRelational(HInstruction instruction) {
       if (instruction is !HRelational) return false;
       HRelational relational = instruction;
-      return relational.builtin;
+      return relational.isBuiltin(types);
     }
 
     if (input is HBoolify && isGenerateAtUseSite(input)) {
       beginExpression(JSPrecedence.EQUALITY_PRECEDENCE);
       use(input.inputs[0], JSPrecedence.EQUALITY_PRECEDENCE);
       buffer.add(' !== true');
       endExpression(JSPrecedence.EQUALITY_PRECEDENCE);
     } else if (isBuiltinRelational(input) &&
                isGenerateAtUseSite(input) &&
-               input.inputs[0].propagatedType.isUseful() &&
-               !input.inputs[0].isDouble() &&
-               input.inputs[1].propagatedType.isUseful() &&
-               !input.inputs[1].isDouble()) {
+               types[input.inputs[0]].isUseful() &&
+               !input.inputs[0].isDouble(types) &&
+               types[input.inputs[1]].isUseful() &&
+               !input.inputs[1].isDouble(types)) {
       // This optimization doesn't work for NaN, so we only do it if the
       // type is known to be non-Double.
       Map<String, String> inverseOperator = const <String>{
         "==" : "!=",
         "!=" : "==",
         "===": "!==",
         "!==": "===",
         "<"  : ">=",
         "<=" : ">",
         ">"  : "<=",
@@ skipping 177 matching lines @@
   }
 
   bool isEmptyString(HInstruction node) {
     if (!node.isConstantString()) return false;
     HConstant constant = node;
     StringConstant string = constant.constant;
     return string.value.length == 0;
   }
 
   void useStringified(HInstruction node, int precedence) {
-    if (node.isString()) {
+    if (node.isString(work.types)) {
       use(node, precedence);
     } else {
       Element convertToString = compiler.findHelper(const SourceString("S"));
       world.registerStaticUse(convertToString);
       buffer.add(compiler.namer.isolateAccess(convertToString));
       buffer.add('(');
       use(node, JSPrecedence.EXPRESSION_PRECEDENCE);
       buffer.add(')');
     }
   }
 
   void visitLiteralList(HLiteralList node) {
     generateArrayLiteral(node);
   }
 
   void generateArrayLiteral(HLiteralList node) {
     buffer.add('[');
     int len = node.inputs.length;
     for (int i = 0; i < len; i++) {
       if (i != 0) buffer.add(', ');
       use(node.inputs[i], JSPrecedence.ASSIGNMENT_PRECEDENCE);
     }
     buffer.add(']');
   }
 
   void visitIndex(HIndex node) {
-    if (node.builtin) {
+    if (node.isBuiltin(work.types)) {
       beginExpression(JSPrecedence.MEMBER_PRECEDENCE);
       use(node.inputs[1], JSPrecedence.MEMBER_PRECEDENCE);
       buffer.add('[');
       use(node.inputs[2], JSPrecedence.EXPRESSION_PRECEDENCE);
       buffer.add(']');
       endExpression(JSPrecedence.MEMBER_PRECEDENCE);
     } else {
       visitInvokeStatic(node);
     }
   }
 
   void visitIndexAssign(HIndexAssign node) {
-    if (node.builtin) {
+    if (node.isBuiltin(work.types)) {
       beginExpression(JSPrecedence.ASSIGNMENT_PRECEDENCE);
       use(node.inputs[1], JSPrecedence.MEMBER_PRECEDENCE);
       buffer.add('[');
       use(node.inputs[2], JSPrecedence.EXPRESSION_PRECEDENCE);
       buffer.add('] = ');
       use(node.inputs[3], JSPrecedence.ASSIGNMENT_PRECEDENCE);
       endExpression(JSPrecedence.ASSIGNMENT_PRECEDENCE);
     } else {
       visitInvokeStatic(node);
     }
   }
 
   String builtinJsName(HInvokeInterceptor interceptor) {
     // Don't count the target method or the receiver in the arity.
     int arity = interceptor.inputs.length - 2;
     HInstruction receiver = interceptor.inputs[1];
     bool getter = interceptor.getter;
     SourceString name = interceptor.name;
 
-    if (interceptor.isLengthGetterOnStringOrArray()) {
+    HTypeMap types = work.types;
+
+    if (interceptor.isLengthGetterOnStringOrArray(types)) {
       return 'length';
-    } else if (receiver.isExtendableArray() && !getter) {
+    } else if (receiver.isExtendableArray(types) && !getter) {
       if (name == const SourceString('add') && arity == 1) {
         return 'push';
       }
       if (name == const SourceString('removeLast') && arity == 0) {
         return 'pop';
       }
-    } else if (receiver.isString() && !getter) {
+    } else if (receiver.isString(types) && !getter) {
       if (name == const SourceString('concat') &&
           arity == 1 &&
-          interceptor.inputs[2].isString()) {
+          interceptor.inputs[2].isString(types)) {
         return '+';
       }
     }
 
     return null;
   }
 
   void visitInvokeInterceptor(HInvokeInterceptor node) {
     String builtin = builtinJsName(node);
     if (builtin !== null) {
@@ skipping 234 matching lines @@
       beginExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
       checkNum(input, '===');
       buffer.add(' && ');
       checkInt(input, '===');
       endExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
     } else if (Elements.isStringSupertype(element, compiler)) {
       handleStringSupertypeCheck(input, element);
     } else if (element === compiler.listClass
                || Elements.isListSupertype(element, compiler)) {
       handleListOrSupertypeCheck(input, element);
-    } else if (input.propagatedType.canBePrimitive()
-               || input.propagatedType.canBeNull()) {
+    } else if (work.types[input].canBePrimitive()
+               || work.types[input].canBeNull()) {
       beginExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
       checkObject(input, '===');
       buffer.add(' && ');
       checkType(input, element);
       endExpression(JSPrecedence.LOGICAL_AND_PRECEDENCE);
     } else {
       checkType(input, element);
     }
     if (compiler.codegenWorld.rti.hasTypeArguments(type)) {
       InterfaceType interfaceType = type;
@@ skipping 175 matching lines @@
     // Make sure we call the bailout method with the number of
     // arguments it expects. This avoids having the underlying
     // JS engine fill them in for us.
     for (; i < maxBailoutParameters; i++) {
       buffer.add(', 0');
     }
     buffer.add(')');
   }
 
   void visitTypeGuard(HTypeGuard node) {
+    HTypeMap types = work.types;
     addIndentation();
     HInstruction input = node.guarded;
     Element indexingBehavior = compiler.jsIndexingBehaviorInterface;
-    if (node.isInteger()) {
+    if (node.isInteger(types)) {
       // if (input is !int) bailout
       buffer.add('if (');
       checkInt(input, '!==');
       buffer.add(') ');
       bailout(node, 'Not an integer');
-    } else if (node.isNumber()) {
+    } else if (node.isNumber(types)) {
       // if (input is !num) bailout
       buffer.add('if (');
       checkNum(input, '!==');
       buffer.add(') ');
       bailout(node, 'Not a number');
-    } else if (node.isBoolean()) {
+    } else if (node.isBoolean(types)) {
       // if (input is !bool) bailout
       buffer.add('if (');
       checkBool(input, '!==');
       buffer.add(') ');
       bailout(node, 'Not a boolean');
-    } else if (node.isString()) {
+    } else if (node.isString(types)) {
       // if (input is !string) bailout
       buffer.add('if (');
       checkString(input, '!==');
       buffer.add(') ');
       bailout(node, 'Not a string');
-    } else if (node.isExtendableArray()) {
+    } else if (node.isExtendableArray(types)) {
       // if (input is !Object || input is !Array || input.isFixed) bailout
       buffer.add('if (');
       checkObject(input, '!==');
       buffer.add('||');
       checkArray(input, '!==');
       buffer.add('||');
       checkFixedArray(input);
       buffer.add(') ');
       bailout(node, 'Not an extendable array');
-    } else if (node.isMutableArray()) {
+    } else if (node.isMutableArray(types)) {
       // if (input is !Object
       //     || ((input is !Array || input.isImmutable)
       //         && input is !JsIndexingBehavior)) bailout
       buffer.add('if (');
       checkObject(input, '!==');
       buffer.add(' || ((');
       checkArray(input, '!==');
       buffer.add(' || ');
       checkImmutableArray(input);
       buffer.add(') && ');
       checkType(input, indexingBehavior, negative: true);
       buffer.add(')) ');
       bailout(node, 'Not a mutable array');
-    } else if (node.isReadableArray()) {
+    } else if (node.isReadableArray(types)) {
       // if (input is !Object
       //     || (input is !Array && input is !JsIndexingBehavior)) bailout
       buffer.add('if (');
       checkObject(input, '!==');
       buffer.add(' || (');
       checkArray(input, '!==');
       buffer.add(' && ');
       checkType(input, indexingBehavior, negative: true);
       buffer.add(')) ');
       bailout(node, 'Not an array');
-    } else if (node.isIndexablePrimitive()) {
+    } else if (node.isIndexablePrimitive(types)) {
       // if (input is !String
       //     && (input is !Object
       //         || (input is !Array && input is !JsIndexingBehavior))) bailout
       buffer.add('if (');
       checkString(input, '!==');
       buffer.add(' && (');
       checkObject(input, '!==');
       buffer.add(' || (');
       checkArray(input, '!==');
       buffer.add(' && ');
@@ skipping 336 matching lines @@
     }
   }
 
   void endLabeledBlock(HLabeledBlockInformation labeledBlockInfo) {
     if (labeledBlockInfo.body.start.hasBailoutTargets()) {
       endBailoutSwitch();
     }
   }
 }
 
-String singleIdentityComparison(HInstruction left, HInstruction right) {
+String singleIdentityComparison(HInstruction left,
+                                HInstruction right,
+                                HTypeMap propagatedTypes) {
   // Returns the single identity comparison (== or ===) or null if a more
   // complex expression is required.
-  HType leftType = left.propagatedType;
-  HType rightType = right.propagatedType;
+  HType leftType = propagatedTypes[left];
+  HType rightType = propagatedTypes[right];
   if (leftType.canBeNull() && rightType.canBeNull()) {
     if (left.isConstantNull() || right.isConstantNull() ||
         (leftType.isPrimitive() && leftType == rightType)) {
       return '==';
     }
     return null;
   } else {
     return '===';
   }
 }