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 113 matching lines @@
   static final int TYPE_DECLARATION = 2;
 
   /**
    * Whether we are currently generating expressions instead of statements.
    * This includes declarations, which are generated as expressions.
    */
   bool isGeneratingExpression = false;
 
   final JavaScriptBackend backend;
   final WorkItem work;
+  final HTypeMap types;
 
   final Set<HInstruction> generateAtUseSite;
   final Set<HInstruction> controlFlowOperators;
   final Map<Element, ElementAction> breakAction;
   final Map<Element, ElementAction> continueAction;
   final Map<Element, String> parameterNames;
 
   js.Block currentContainer;
   js.Block get body() => currentContainer;
   List<js.Expression> expressionStack;
@@ skipping 22 matching lines @@
   HGraph currentGraph;
   HBasicBlock currentBlock;
 
   // Records a block-information that is being handled specially.
   // Used to break bad recursion.
   HBlockInformation currentBlockInformation;
   // The subgraph is used to delimit traversal for some constructions, e.g.,
   // if branches.
   SubGraph subGraph;
 
+  SsaCodeGenerator(this.backend,
+                   WorkItem work,
+                   this.parameterNames)
+    : this.work = work,
+      this.types =
+          (work.compilationContext as JavaScriptItemCompilationContext).types,
+      declaredVariables = new Set<String>(),
+      delayedVariableDeclarations = new Set<String>(),
+      currentContainer = new js.Block.empty(),
+      expressionStack = <js.Expression>[],
+      oldContainerStack = <js.Block>[],
+      generateAtUseSite = new Set<HInstruction>(),
+      controlFlowOperators = new Set<HInstruction>(),
+      breakAction = new Map<Element, ElementAction>(),
+      continueAction = new Map<Element, ElementAction>();
+
   LibraryElement get currentLibrary() => work.element.getLibrary();
   Compiler get compiler() => backend.compiler;
   NativeEmitter get nativeEmitter() => backend.emitter.nativeEmitter;
   Enqueuer get world() => backend.compiler.enqueuer.codegen;
 
   bool isGenerateAtUseSite(HInstruction instruction) {
     return generateAtUseSite.contains(instruction);
   }
 
   bool isNonNegativeInt32Constant(HInstruction instruction) {
@@ skipping 84 matching lines @@
     }
     return jsNode;
   }
 
   js.Node attachLocationRange(js.Node jsNode, Node node) {
     jsNode.sourcePosition = node.getBeginToken();
     jsNode.endSourcePosition = node.getEndToken();
     return jsNode;
   }
 
-  SsaCodeGenerator(this.backend,
-                   this.work,
-                   this.parameterNames)
-    : declaredVariables = new Set<String>(),
-      delayedVariableDeclarations = new Set<String>(),
-      currentContainer = new js.Block.empty(),
-      expressionStack = <js.Expression>[],
-      oldContainerStack = <js.Block>[],
-      generateAtUseSite = new Set<HInstruction>(),
-      controlFlowOperators = new Set<HInstruction>(),
-      breakAction = new Map<Element, ElementAction>(),
-      continueAction = new Map<Element, ElementAction>();
-
   abstract visitTypeGuard(HTypeGuard node);
   abstract visitBailoutTarget(HBailoutTarget node);
 
   abstract beginGraph(HGraph graph);
   abstract endGraph(HGraph graph);
 
   abstract beginLoop(HBasicBlock block);
   abstract endLoop(HBasicBlock block);
   abstract handleLoopCondition(HLoopBranch node);
 
   abstract preLabeledBlock(HLabeledBlockInformation labeledBlockInfo);
   abstract startLabeledBlock(HLabeledBlockInformation labeledBlockInfo);
   abstract endLabeledBlock(HLabeledBlockInformation labeledBlockInfo);
 
   void preGenerateMethod(HGraph graph) {
-    new SsaInstructionMerger(generateAtUseSite).visitGraph(graph);
-    new SsaConditionMerger(generateAtUseSite,
-                           controlFlowOperators).visitGraph(graph);
+    new SsaInstructionMerger(types, generateAtUseSite).visitGraph(graph);
+    new SsaConditionMerger(
+        types, 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 806 matching lines @@
       } else if (!isGenerateAtUseSite(instruction)) {
         define(instruction);
       }
       instruction = instruction.next;
     }
     assignPhisOfSuccessors(node);
     visit(instruction);
   }
 
   visitInvokeBinary(HInvokeBinary node, String op) {
-    if (node.builtin) {
+    if (node.isBuiltin(types)) {
       use(node.left);
       js.Expression jsLeft = pop();
       use(node.right);
       push(new js.Binary(op, jsLeft, pop()), node);
     } 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) {
     visitInvokeBinary(node, op);
-    if (node.builtin && requiresUintConversion(node)) {
+    if (node.isBuiltin(types) && requiresUintConversion(node)) {
       push(new js.Binary(">>>", pop(), new js.LiteralNumber("0")), node);
     }
   }
 
   visitInvokeUnary(HInvokeUnary node, String op) {
-    if (node.builtin) {
+    if (node.isBuiltin(types)) {
       use(node.operand);
       push(new js.Prefix(op, pop()), node);
     } 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) {
     visitInvokeUnary(node, op);
-    if (node.builtin && requiresUintConversion(node)) {
+    if (node.isBuiltin(types) && requiresUintConversion(node)) {
       push(new js.Binary(">>>", pop(), new js.LiteralNumber("0")), node);
     }
   }
 
   void emitIdentityComparison(HInstruction left, HInstruction right) {
-    String op = singleIdentityComparison(left, right);
+    String op = singleIdentityComparison(left, right, types);
     if (op != null) {
       use(left);
       js.Expression jsLeft = pop();
       use(right);
       push(new js.Binary(op, jsLeft, pop()));
     } else {
       assert(NullConstant.JsNull == 'null');
       use(left);
       js.Binary leftEqualsNull =
           new js.Binary("==", pop(), new js.LiteralNull());
       use(right);
       js.Binary rightEqualsNull =
           new js.Binary("==", pop(), new js.LiteralNull());
       use(right);
       use(left);
       js.Binary tripleEq = new js.Binary("===", pop(), pop());
 
       push(new js.Conditional(leftEqualsNull, rightEqualsNull, tripleEq));
     }
   }
 
   visitEquals(HEquals node) {
-    if (node.builtin) {
+    if (node.isBuiltin(types)) {
       emitIdentityComparison(node.left, node.right);
     } else {
       visitInvokeStatic(node);
     }
   }
 
   visitIdentity(HIdentity node) {
-    assert(node.builtin);
+    assert(node.isBuiltin(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 184 matching lines @@
       methodName = node.name.slowToString();
       arguments = visitArguments(node.inputs);
     } else {
       methodName = compiler.namer.instanceMethodInvocationName(
           currentLibrary, node.name, node.selector);
       arguments = visitArguments(node.inputs);
       bool inLoop = node.block.enclosingLoopHeader !== null;
 
       // Register this invocation to collect the types used at all call sites.
       Selector selector = getOptimizedSelectorFor(node, node.selector);
-      backend.registerDynamicInvocation(node, selector);
+      backend.registerDynamicInvocation(node, selector, types);
 
       // If we don't know what we're calling or if we are calling a getter,
       // we need to register that fact that we may be calling a closure
       // with the same arguments.
       Element target = node.element;
       if (target === null || target.isGetter()) {
         // TODO(kasperl): If we have a typed selector for the call, we
         // may know something about the types of closures that need
         // the specific closure call method.
         Selector call = new Selector.callClosureFrom(selector);
@@ skipping 10 matching lines @@
         world.registerDynamicInvocation(node.name, selector);
       }
     }
     push(jsPropertyCall(object, methodName, arguments), node);
   }
 
   Selector getOptimizedSelectorFor(HInvokeDynamic node,
                                    Selector defaultSelector) {
     // TODO(4434): For private members we need to use the untyped selector.
     if (node.name.isPrivate()) return defaultSelector;
-    Type receiverType = node.inputs[0].propagatedType.computeType(compiler);
+    HType receiverHType = types[node.inputs[0]];
+    Type receiverType = receiverHType.computeType(compiler);
     if (receiverType !== null) {
       return new TypedSelector(receiverType, defaultSelector);
     } else {
       return defaultSelector;
     }
   }
 
   visitInvokeDynamicSetter(HInvokeDynamicSetter node) {
     use(node.receiver);
     push(jsPropertyCall(pop(),
@@ skipping 23 matching lines @@
                         visitArguments(node.inputs)),
          node);
     Selector call = new Selector.callClosureFrom(node.selector);
     world.registerDynamicInvocation(call.name, call);
   }
 
   visitInvokeStatic(HInvokeStatic node) {
     if (Elements.isStaticOrTopLevelFunction(node.element) &&
         node.typeCode() == HInvokeStatic.INVOKE_STATIC_TYPECODE) {
       // Register this invocation to collect the types used at all call sites.
-      backend.registerStaticInvocation(node);
+      backend.registerStaticInvocation(node, types);
     }
     use(node.target);
     push(new js.Call(pop(), visitArguments(node.inputs)), node);
   }
 
   visitInvokeSuper(HInvokeSuper node) {
     Element superMethod = node.element;
     Element superClass = superMethod.getEnclosingClass();
     // Remove the element and 'this'.
     int argumentCount = node.inputs.length - 2;
@@ skipping 45 matching lines @@
         compiler.namer.instanceFieldName(node.library, node.fieldName);
     use(node.receiver);
     push(new js.PropertyAccess.field(pop(), name), node);
     if (node.element == null) {
       // If we don't have an element we register a dynamic field getter.
       // This might lead to unnecessary getters, but these cases should be
       // rare.
       Selector getter = new Selector.getter(node.fieldName, node.library);
       world.registerDynamicGetter(node.fieldName, getter);
     } else {
-      Type type = node.receiver.propagatedType.computeType(compiler);
+      HType receiverHType = types[node.receiver];
+      Type type = receiverHType.computeType(compiler);
       if (type != null) {
         world.registerFieldGetter(node.element.name, node.library, 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) {
@@ skipping 17 matching lines @@
     }
     String name =
         compiler.namer.instanceFieldName(node.library, node.fieldName);
     if (node.element == null) {
       // If we don't have an element we register a dynamic field setter.
       // This might lead to unnecessary setters, but these cases should be
       // rare.
       Selector setter = new Selector.setter(node.fieldName, node.library);
       world.registerDynamicSetter(node.fieldName, setter);
     } else {
-      Type type = node.receiver.propagatedType.computeType(compiler);
+      Type type = types[node.receiver].computeType(compiler);
       if (type != null) {
         if (!work.element.isGenerativeConstructorBody()) {
           world.registerFieldSetter(node.element.name, node.library, 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]);
         }
       }
     }
     use(node.receiver);
     js.Expression receiver = pop();
     use(node.value);
     push(new js.Assignment(new js.PropertyAccess.field(receiver, name), pop()),
          node);
   }
 
   visitLocalGet(HLocalGet node) {
     use(node.receiver);
   }
 
   visitLocalSet(HLocalSet node) {
     use(node.value);
     assignVariable(variableNames.getName(node.receiver), pop());
   }
 
   visitForeign(HForeign node) {
     String code = node.code.slowToString();
     List<HInstruction> inputs = node.inputs;
-    if (node.isStatement) {
+    if (node.isStatement(types)) {
       if (!inputs.isEmpty()) {
         compiler.internalError("foreign statement with inputs: $code",
                                instruction: node);
       }
       pushStatement(new js.LiteralStatement(code), node);
     } else {
       List<js.Expression> data = <js.Expression>[];
       for (int i = 0; i < inputs.length; i++) {
         use(inputs[i]);
         data.add(pop());
       }
       push(new js.LiteralExpression.withData(code, data), node);
     }
   }
 
   visitForeignNew(HForeignNew node) {
     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);
     List<HInstruction> inputs = node.inputs;
     // We can't use 'visitArguments', since our arguments start at input[0].
     List<js.Expression> arguments = <js.Expression>[];
     for (int i = 0; i < inputs.length; i++) {
       use(inputs[i]);
       arguments.add(pop());
     }
@@ skipping 77 matching lines @@
     assert(node.inputs.length == 1);
     generateNot(node.inputs[0]);
     attachLocationToLast(node);
   }
 
 
   void generateNot(HInstruction input) {
     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)) {
       use(input.inputs[0]);
       push(new js.Binary("!==", pop(), new js.LiteralBool(true)), input);
     } 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 181 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) {
-    if (node.isString()) {
+    if (node.isString(types)) {
       use(node);
     } else {
       Element convertToString = compiler.findHelper(const SourceString("S"));
       world.registerStaticUse(convertToString);
       js.VariableUse variableUse =
           new js.VariableUse(compiler.namer.isolateAccess(convertToString));
       use(node);
       push(new js.Call(variableUse, <js.Expression>[pop()]), node);
     }
   }
 
   void visitLiteralList(HLiteralList node) {
     generateArrayLiteral(node);
   }
 
   void generateArrayLiteral(HLiteralList node) {
     int len = node.inputs.length;
     List<js.ArrayElement> elements = <js.ArrayElement>[];
     for (int i = 0; i < len; i++) {
       use(node.inputs[i]);
       elements.add(new js.ArrayElement(i, pop()));
     }
     push(new js.ArrayInitializer(len, elements), node);
   }
 
   void visitIndex(HIndex node) {
-    if (node.builtin) {
+    if (node.isBuiltin(types)) {
       use(node.inputs[1]);
       js.Expression receiver = pop();
       use(node.inputs[2]);
       push(new js.PropertyAccess(receiver, pop()), node);
     } else {
       visitInvokeStatic(node);
     }
   }
 
   void visitIndexAssign(HIndexAssign node) {
-    if (node.builtin) {
+    if (node.isBuiltin(types)) {
       use(node.inputs[1]);
       js.Expression receiver = pop();
       use(node.inputs[2]);
       js.Expression index = pop();
       use(node.inputs[3]);
       push(new js.Assignment(new js.PropertyAccess(receiver, index), pop()),
            node);
     } 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()) {
+    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 188 matching lines @@
       js.Expression numTest = pop();
       checkInt(input, '===');
       push(new js.Binary('&&', numTest, pop()), node);
     } else if (Elements.isStringSupertype(element, compiler)) {
       handleStringSupertypeCheck(input, element);
       attachLocationToLast(node);
     } else if (element === compiler.listClass
                || Elements.isListSupertype(element, compiler)) {
       handleListOrSupertypeCheck(input, element);
       attachLocationToLast(node);
-    } else if (input.propagatedType.canBePrimitive()
-               || input.propagatedType.canBeNull()) {
+    } else if (types[input].canBePrimitive() || types[input].canBeNull()) {
       checkObject(input, '===');
       js.Expression objectTest = pop();
       checkType(input, element);
       push(new js.Binary('&&', objectTest, pop()), node);
     } else {
       checkType(input, element);
       attachLocationToLast(node);
     }
     if (compiler.codegenWorld.rti.hasTypeArguments(type)) {
       InterfaceType interfaceType = type;
@@ skipping 190 matching lines @@
       bailoutTarget = new js.VariableUse(namer.isolateBailoutAccess(element));
     }
     js.Call call = new js.Call(bailoutTarget, arguments);
     attachLocation(call, guard);
     return new js.Return(call);
   }
 
   void visitTypeGuard(HTypeGuard node) {
     HInstruction input = node.guarded;
     Element indexingBehavior = compiler.jsIndexingBehaviorInterface;
-    if (node.isInteger()) {
+    if (node.isInteger(types)) {
       // if (input is !int) bailout
       checkInt(input, '!==');
       pushStatement(new js.If.then(pop(), bailout(node, 'Not an integer')),
                     node);
-    } else if (node.isNumber()) {
+    } else if (node.isNumber(types)) {
       // if (input is !num) bailout
       checkNum(input, '!==');
       pushStatement(new js.If.then(pop(), bailout(node, 'Not a number')), node);
-    } else if (node.isBoolean()) {
+    } else if (node.isBoolean(types)) {
       // if (input is !bool) bailout
       checkBool(input, '!==');
       pushStatement(new js.If.then(pop(), bailout(node, 'Not a boolean')),
                     node);
-    } else if (node.isString()) {
+    } else if (node.isString(types)) {
       // if (input is !string) bailout
       checkString(input, '!==');
       pushStatement(new js.If.then(pop(), bailout(node, 'Not a string')), node);
-    } else if (node.isExtendableArray()) {
+    } else if (node.isExtendableArray(types)) {
       // if (input is !Object || input is !Array || input.isFixed) bailout
       checkObject(input, '!==');
       js.Expression objectTest = pop();
       checkArray(input, '!==');
       js.Expression arrayTest = pop();
       checkFixedArray(input);
       js.Expression test = new js.Binary('||', objectTest, arrayTest);
       test = new js.Binary('||', test, pop());
       pushStatement(new js.If.then(test,
                                    bailout(node, 'Not an extendable array')),
                     node);
-    } else if (node.isMutableArray()) {
+    } else if (node.isMutableArray(types)) {
       // if (input is !Object
       //     || ((input is !Array || input.isImmutable)
       //         && input is !JsIndexingBehavior)) bailout
       checkObject(input, '!==');
       js.Expression objectTest = pop();
       checkArray(input, '!==');
       js.Expression arrayTest = pop();
       checkImmutableArray(input);
       js.Binary notArrayOrImmutable = new js.Binary('||', arrayTest, pop());
       checkType(input, indexingBehavior, negative: true);
       js.Binary notIndexing = new js.Binary('&&', notArrayOrImmutable, pop());
       pushStatement(new js.If.then(new js.Binary('||', objectTest, notIndexing),
                                    bailout(node, 'Not a mutable array')),
                     node);
-    } else if (node.isReadableArray()) {
+    } else if (node.isReadableArray(types)) {
       // if (input is !Object
       //     || (input is !Array && input is !JsIndexingBehavior)) bailout
       checkObject(input, '!==');
       js.Expression objectTest = pop();
       checkArray(input, '!==');
       js.Expression arrayTest = pop();
       checkType(input, indexingBehavior, negative: true);
       js.Expression notIndexing = new js.Binary('&&', arrayTest, pop());
       pushStatement(new js.If.then(new js.Binary('||', objectTest, notIndexing),
                                    bailout(node, 'Not an array')),
                     node);
-    } else if (node.isIndexablePrimitive()) {
+    } else if (node.isIndexablePrimitive(types)) {
       // if (input is !String
       //     && (input is !Object
       //         || (input is !Array && input is !JsIndexingBehavior))) bailout
       checkString(input, '!==');
       js.Expression stringTest = pop();
       checkObject(input, '!==');
       js.Expression objectTest = pop();
       checkArray(input, '!==');
       js.Expression arrayTest = pop();
       checkType(input, indexingBehavior, negative: true);
@@ skipping 357 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 '===';
   }
 }