Move types out of the HInstructions.

lib/compiler/implementation/ssa/optimize.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 OptimizationPhase {
   String get name();
   void visitGraph(HGraph graph);
 }
 
 class SsaOptimizerTask extends CompilerTask {
   final JavaScriptBackend backend;
   SsaOptimizerTask(JavaScriptBackend backend)
     : this.backend = backend,
       super(backend.compiler);
   String get name() => 'SSA optimizer';
   Compiler get compiler() => backend.compiler;
 
   void runPhases(HGraph graph, List<OptimizationPhase> phases) {
     for (OptimizationPhase phase in phases) {
-      phase.visitGraph(graph);
-      compiler.tracer.traceGraph(phase.name, graph);
+      runPhase(graph, phase);
     }
   }
 
+  void runPhase(HGraph graph, OptimizationPhase phase) {
+    phase.visitGraph(graph);
+    compiler.tracer.traceGraph(phase.name, graph);
+  }
+
   void optimize(WorkItem work, HGraph graph) {
+    JavaScriptItemCompilationContext context = work.compilationContext;
+    HTypeMap types = context.types;
     measure(() {
       List<OptimizationPhase> phases = <OptimizationPhase>[
           // Run trivial constant folding first to optimize
           // some patterns useful for type conversion.
-          new SsaConstantFolder(backend, work),
+          new SsaConstantFolder(backend, work, types),
           new SsaTypeConversionInserter(compiler),
-          new SsaTypePropagator(compiler),
-          new SsaCheckInserter(backend),
-          new SsaConstantFolder(backend, work),
+          new SsaTypePropagator(compiler, types),
+          new SsaCheckInserter(backend, types),
+          new SsaConstantFolder(backend, work, types),
           new SsaRedundantPhiEliminator(),
           new SsaDeadPhiEliminator(),
-          new SsaGlobalValueNumberer(compiler),
+          new SsaGlobalValueNumberer(compiler, types),
           new SsaCodeMotion(),
-          new SsaDeadCodeEliminator(),
-          new SsaRegisterRecompilationCandidates(backend, work)];
+          new SsaDeadCodeEliminator(types),
+          new SsaRegisterRecompilationCandidates(backend, work, types)];
       runPhases(graph, phases);
     });
   }
 
   bool trySpeculativeOptimizations(WorkItem work, HGraph graph) {
+    JavaScriptItemCompilationContext context = work.compilationContext;
+    HTypeMap types = context.types;
     return measure(() {
       // Run the phases that will generate type guards.
       List<OptimizationPhase> phases = <OptimizationPhase>[
-          new SsaRecompilationFieldTypePropagator(backend, work),
-          new SsaSpeculativeTypePropagator(compiler),
-          new SsaTypeGuardInserter(compiler, work),
+          new SsaRecompilationFieldTypePropagator(backend, work, types),
+          new SsaSpeculativeTypePropagator(compiler, types),
+          new SsaTypeGuardInserter(compiler, work, types),
           new SsaEnvironmentBuilder(compiler),
           // Change the propagated types back to what they were before we
           // speculatively propagated, so that we can generate the bailout
           // version.
           // Note that we do this even if there were no guards inserted. If a
           // guard is not beneficial enough we don't emit one, but there might
           // still be speculative types on the instructions.
-          new SsaTypePropagator(compiler),
+          new SsaTypePropagator(compiler, types),
           // Then run the [SsaCheckInserter] because the type propagator also
           // propagated types non-speculatively. For example, it might have
           // propagated the type array for a call to the List constructor.
-          new SsaCheckInserter(backend)];
+          new SsaCheckInserter(backend, types)];
       runPhases(graph, phases);
       return !work.guards.isEmpty();
     });
   }
 
   void prepareForSpeculativeOptimizations(WorkItem work, HGraph graph) {
+    JavaScriptItemCompilationContext context = work.compilationContext;
+    HTypeMap types = context.types;
     measure(() {
       // In order to generate correct code for the bailout version, we did not
       // propagate types from the instruction to the type guard. We do it
       // now to be able to optimize further.
       work.guards.forEach((HTypeGuard guard) { guard.isEnabled = true; });
       // We also need to insert range and integer checks for the type
       // guards. Now that they claim to have a certain type, some
       // depending instructions might become builtin (like native array
       // accesses) and need to be checked.
       // Also run the type propagator, to please the codegen in case
       // no other optimization is run.
       runPhases(graph,
-        <OptimizationPhase>[new SsaCheckInserter(backend),
-                            new SsaTypePropagator(compiler)]);
+        <OptimizationPhase>[new SsaCheckInserter(backend, types),
+                            new SsaTypePropagator(compiler, types)]);
     });
   }
 }
 
 /**
  * If both inputs to known operations are available execute the operation at
  * compile-time.
  */
 class SsaConstantFolder extends HBaseVisitor implements OptimizationPhase {
   final String name = "SsaConstantFolder";
   final JavaScriptBackend backend;
   final WorkItem work;
+  final HTypeMap types;
   HGraph graph;
   Compiler get compiler() => backend.compiler;
 
-  SsaConstantFolder(this.backend, this.work);
+  SsaConstantFolder(this.backend, this.work, this.types);
 
   void visitGraph(HGraph visitee) {
     graph = visitee;
     visitDominatorTree(visitee);
   }
 
   visitBasicBlock(HBasicBlock block) {
     HInstruction instruction = block.first;
     while (instruction !== null) {
       HInstruction next = instruction.next;
       HInstruction replacement = instruction.accept(this);
       if (replacement !== instruction) {
         if (!replacement.isInBasicBlock()) {
           // The constant folding can return an instruction that is already
           // part of the graph (like an input), so we only add the replacement
           // if necessary.
           block.addAfter(instruction, replacement);
         }
         block.rewrite(instruction, replacement);
         block.remove(instruction);
         // If the replacement instruction does not know its type or
         // source element yet, use the type and source element of the
         // instruction.
-        if (!replacement.propagatedType.isUseful()) {
-          replacement.propagatedType = instruction.propagatedType;
+        if (!types[replacement].isUseful()) {
+          types[replacement] = types[instruction];
         }
         if (replacement.sourceElement === null) {
           replacement.sourceElement = instruction.sourceElement;
         }
       }
       instruction = next;
     }
   }
 
   HInstruction visitInstruction(HInstruction node) {
     return node;
   }
 
   HInstruction visitBoolify(HBoolify node) {
     List<HInstruction> inputs = node.inputs;
     assert(inputs.length == 1);
     HInstruction input = inputs[0];
-    if (input.isBoolean()) return input;
+    if (input.isBoolean(types)) return input;
     // All values !== true are boolified to false.
-    Type type = input.propagatedType.computeType(compiler);
+    Type type = types[input].computeType(compiler);
     if (type !== null && type.element !== compiler.boolClass) {
       return graph.addConstantBool(false);
     }
     return node;
   }
 
   HInstruction visitNot(HNot node) {
     List<HInstruction> inputs = node.inputs;
     assert(inputs.length == 1);
     HInstruction input = inputs[0];
@@ skipping 29 matching lines @@
         HConstant constantInput = input;
         ListConstant constant = constantInput.constant;
         return graph.addConstantInt(constant.length);
       } else if (input.isConstantMap()) {
         HConstant constantInput = input;
         MapConstant constant = constantInput.constant;
         return graph.addConstantInt(constant.length);
       }
     }
 
-    if (input.isString()
+    if (input.isString(types)
         && node.name == const SourceString('toString')) {
       return node.inputs[1];
     }
 
-    if (!input.canBePrimitive() && !node.getter && !node.setter) {
+    if (!input.canBePrimitive(types) && !node.getter && !node.setter) {
       bool transformToDynamicInvocation = true;
-      if (input.canBeNull()) {
+      if (input.canBeNull(types)) {
         // Check if the method exists on Null. If yes we must not transform
         // the static interceptor call to a dynamic invocation.
         // TODO(floitsch): get a list of methods that exist on 'null' and only
         // bail out on them.
         transformToDynamicInvocation = false;
       }
       if (transformToDynamicInvocation) {
         return fromInterceptorToDynamicInvocation(node, node.selector);
       }
     }
 
     return node;
   }
 
   HInstruction visitInvokeDynamic(HInvokeDynamic node) {
-    HType receiverType = node.receiver.propagatedType;
+    HType receiverType = types[node.receiver];
     if (receiverType.isExact()) {
       HBoundedType type = receiverType;
       Element element = type.lookupMember(node.name);
       // TODO(ngeoffray): Also fold if it's a getter or variable.
       if (element != null && element.isFunction()) {
         if (node.selector.applies(element, compiler)) {
           FunctionElement method = element;
           FunctionSignature parameters = method.computeSignature(compiler);
           if (parameters.optionalParameterCount == 0) {
             node.element = element;
           }
           // TODO(ngeoffray): If the method has optional parameters,
           // we should pass the default values here.
         }
       }
     }
     return node;
   }
 
   HInstruction fromInterceptorToDynamicInvocation(HInvokeStatic node,
                                                   Selector selector) {
-    HBoundedType type = node.inputs[1].propagatedType;
+    HBoundedType type = types[node.inputs[1]];
     HInvokeDynamicMethod result = new HInvokeDynamicMethod(
         selector,
         selector.name,
         node.inputs.getRange(1, node.inputs.length - 1));
     if (type.isExact()) {
       HBoundedType concrete = type;
       result.element = concrete.lookupMember(selector.name);
     }
     return result;
   }
@@ skipping 31 matching lines @@
         }
         return node;
       }
       node.staticChecks = HBoundsCheck.ALWAYS_ABOVE_ZERO;
     }
     return node;
   }
 
   HInstruction visitIntegerCheck(HIntegerCheck node) {
     HInstruction value = node.value;
-    if (value.isInteger()) return value;
+    if (value.isInteger(types)) return value;
     if (value.isConstant()) {
       assert((){
         HConstant constantInstruction = value;
         return !constantInstruction.constant.isInt();
       });
       node.alwaysFalse = true;
     }
     return node;
   }
 
 
   HInstruction visitIndex(HIndex node) {
-    if (!node.receiver.canBePrimitive()) {
+    if (!node.receiver.canBePrimitive(types)) {
       Selector selector = new Selector.index();
       return fromInterceptorToDynamicInvocation(node, selector);
     }
     return node;
   }
 
   HInstruction visitIndexAssign(HIndexAssign node) {
-    if (!node.receiver.canBePrimitive()) {
+    if (!node.receiver.canBePrimitive(types)) {
       Selector selector = new Selector.indexSet();
       return fromInterceptorToDynamicInvocation(node, selector);
     }
     return node;
   }
 
   HInstruction visitInvokeBinary(HInvokeBinary node) {
     HInstruction left = node.left;
     HInstruction right = node.right;
     if (left is HConstant && right is HConstant) {
       BinaryOperation operation = node.operation;
       HConstant op1 = left;
       HConstant op2 = right;
       Constant folded = operation.fold(op1.constant, op2.constant);
       if (folded !== null) return graph.addConstant(folded);
     }
 
-    if (!left.canBePrimitive()
+    if (!left.canBePrimitive(types)
         && node.operation.isUserDefinable()
         // The equals operation is being optimized in visitEquals.
         && node.operation !== const EqualsOperation()) {
       Selector selector = new Selector.binaryOperator(node.operation.name);
       return fromInterceptorToDynamicInvocation(node, selector);
     }
     return node;
   }
 
   bool allUsersAreBoolifies(HInstruction instruction) {
@@ skipping 17 matching lines @@
         // instructions. If it is unused it will be treated as dead code and
         // discarded.
         oldTarget.block.addAfter(oldTarget, boolifiedTarget);
         // Remove us as user from the [oldTarget].
         oldTarget.removeUser(node);
         // Replace old target with boolified target.
         assert(node.target == node.inputs[0]);
         node.inputs[0] = boolifiedTarget;
         boolifiedTarget.usedBy.add(node);
         node.usesBoolifiedInterceptor = true;
-        node.propagatedType = HType.BOOLEAN;
+        types[node] = HType.BOOLEAN;
       }
       // This node stays the same, but the Boolify node will go away.
     }
     // Note that we still have to call [super] to make sure that we end up
     // in the remaining optimizations.
     return super.visitRelational(node);
   }
 
   HInstruction handleIdentityCheck(HInvokeBinary node) {
     HInstruction left = node.left;
     HInstruction right = node.right;
-    HType leftType = left.propagatedType;
-    HType rightType = right.propagatedType;
+    HType leftType = types[left];
+    HType rightType = types[right];
     assert(!leftType.isConflicting() && !rightType.isConflicting());
 
     // We don't optimize on numbers to preserve the runtime semantics.
-    if (!(left.isNumber() && right.isNumber()) &&
+    if (!(left.isNumber(types) && right.isNumber(types)) &&
         leftType.intersection(rightType).isConflicting()) {
       return graph.addConstantBool(false);
     }
 
-    if (left.isConstantBoolean() && right.isBoolean()) {
+    if (left.isConstantBoolean() && right.isBoolean(types)) {
       HConstant constant = left;
       if (constant.constant.isTrue()) {
         return right;
       } else {
         return new HNot(right);
       }
     }
 
-    if (right.isConstantBoolean() && left.isBoolean()) {
+    if (right.isConstantBoolean() && left.isBoolean(types)) {
       HConstant constant = right;
       if (constant.constant.isTrue()) {
         return left;
       } else {
         return new HNot(left);
       }
     }
 
     return null;
   }
@@ skipping 13 matching lines @@
       return new HIdentity(target, node.left, node.right);
     } else {
       return newInstruction;
     }
   }
 
   HInstruction visitEquals(HEquals node) {
     HInstruction left = node.left;
     HInstruction right = node.right;
 
-    if (node.builtin) {
+    if (node.isBuiltin(types)) {
       return foldBuiltinEqualsCheck(node);
     }
 
     if (left.isConstant() && right.isConstant()) {
       return super.visitEquals(node);
     }
 
-    if (left.propagatedType.isExact()) {
-      HBoundedType type = left.propagatedType;
+    HType leftType = types[left];
+    if (leftType.isExact()) {
+      HBoundedType type = leftType;
       Element element = type.lookupMember(Elements.OPERATOR_EQUALS);
       if (element !== null) {
         // If the left-hand side is guaranteed to be a non-primitive
         // type and and it defines operator==, we emit a call to that
         // operator.
         return super.visitEquals(node);
       } else if (right.isConstantNull()) {
         return graph.addConstantBool(false);
       } else {
         // We can just emit an identity check because the type does
         // not implement operator=.
         return foldBuiltinEqualsCheck(node);
       }
     }
 
     if (right.isConstantNull()) {
-      if (left.propagatedType.isPrimitive()) {
+      if (leftType.isPrimitive()) {
         return graph.addConstantBool(false);
       }
     }
 
     // All other cases are dealt with by the [visitRelational] and
     // [visitInvokeBinary], which are visited by invoking the [super]'s
     // visit method.
     return super.visitEquals(node);
   }
 
   HInstruction visitTypeGuard(HTypeGuard node) {
     HInstruction value = node.guarded;
     // If the intersection of the types is still the incoming type then
     // the incoming type was a subtype of the guarded type, and no check
     // is required.
-    HType combinedType = value.propagatedType.intersection(node.guardedType);
-    return (combinedType == value.propagatedType) ? value : node;
+    HType combinedType = types[value].intersection(node.guardedType);
+    return (combinedType == types[value]) ? value : node;
   }
 
   HInstruction visitIs(HIs node) {
     Type type = node.typeExpression;
     Element element = type.element;
     if (element.kind === ElementKind.TYPE_VARIABLE) {
       compiler.unimplemented("visitIs for type variables");
     }
 
-    HType expressionType = node.expression.propagatedType;
+    HType expressionType = types[node.expression];
     if (element === compiler.objectClass
         || element === compiler.dynamicClass) {
       return graph.addConstantBool(true);
     } else if (expressionType.isInteger()) {
       if (element === compiler.intClass || element === compiler.numClass) {
         return graph.addConstantBool(true);
       } else if (element === compiler.doubleClass) {
         // We let the JS semantics decide for that check. Currently
         // the code we emit will always return true.
         return node;
@@ skipping 42 matching lines @@
         } else if (expressionType.isExact()) {
           return graph.addConstantBool(false);
         }
       }
     }
     return node;
   }
 
   HInstruction visitTypeConversion(HTypeConversion node) {
     HInstruction value = node.inputs[0];
-    Type type = node.propagatedType.computeType(compiler);
+    Type type = types[node].computeType(compiler);
     if (type.element === compiler.dynamicClass
         || type.element === compiler.objectClass) {
       return value;
     }
-    HType combinedType = value.propagatedType.intersection(node.propagatedType);
-    return (combinedType == value.propagatedType) ? value : node;
+    HType combinedType = types[value].intersection(types[node]);
+    return (combinedType == types[value]) ? value : node;
   }
 
   HInstruction visitInvokeDynamicGetter(HInvokeDynamicGetter node) {
     HInstruction receiver = node.inputs[0];
-    if (!receiver.propagatedType.isUseful()) return node;
-    if (receiver.propagatedType.canBeNull()) return node;
-    Type type = receiver.propagatedType.computeType(compiler);
+    HType receiverType = types[receiver];
+    if (!receiverType.isUseful()) return node;
+    if (receiverType.canBeNull()) return node;
+    Type type = receiverType.computeType(compiler);
     if (type === null) return node;
     Element field = compiler.world.locateSingleField(type, node.name);
     if (field === null) return node;
     if (node.name.isPrivate() &&
         field.getLibrary() !== work.element.getLibrary()) {
       return node;
     }
     Modifiers modifiers = field.modifiers;
     bool isFinalOrConst = false;
     if (modifiers != null) {
@@ skipping 19 matching lines @@
           isFinalOrConst = true;
           break;
       }
     }
     return new HFieldGet.withElement(
         field, node.inputs[0], isFinalOrConst: isFinalOrConst);
   }
 
   HInstruction visitInvokeDynamicSetter(HInvokeDynamicSetter node) {
     HInstruction receiver = node.inputs[0];
-    if (!receiver.propagatedType.isUseful()) return node;
-    if (receiver.propagatedType.canBeNull()) return node;
-    Type type = receiver.propagatedType.computeType(compiler);
+    HType receiverType = types[receiver];
+    if (!receiverType.isUseful()) return node;
+    if (receiverType.canBeNull()) return node;
+    Type type = receiverType.computeType(compiler);
     if (type === null) return node;
     Element field = compiler.world.locateSingleField(type, node.name);
     if (field === null) return node;
     return new HFieldSet.withElement(field, node.inputs[0], node.inputs[1]);
   }
 
   HInstruction visitStringConcat(HStringConcat node) {
     DartString folded = const LiteralDartString("");
     for (int i = 0; i < node.inputs.length; i++) {
       HInstruction part = node.inputs[i];
       if (!part.isConstant()) return node;
       HConstant constant = part;
       if (!constant.constant.isPrimitive()) return node;
       PrimitiveConstant primitive = constant.constant;
       folded = new DartString.concat(folded, primitive.toDartString());
     }
     return graph.addConstantString(folded, node.node);
   }
 }
 
 class SsaCheckInserter extends HBaseVisitor implements OptimizationPhase {
+  final HTypeMap types;
   final String name = "SsaCheckInserter";
   Element lengthInterceptor;
 
-  SsaCheckInserter(JavaScriptBackend backend) {
+  SsaCheckInserter(JavaScriptBackend backend, this.types) {
     SourceString lengthString = const SourceString('length');
     lengthInterceptor =
         backend.builder.interceptors.getStaticGetInterceptor(lengthString);
   }
 
   void visitGraph(HGraph graph) {
     visitDominatorTree(graph);
   }
 
   void visitBasicBlock(HBasicBlock block) {
@@ skipping 12 matching lines @@
     node.block.addBefore(node, interceptor);
     Selector selector = new Selector.call(
         lengthInterceptor.name,
         lengthInterceptor.getLibrary(),  // TODO(kasperl): Wrong.
         0);
     HInvokeInterceptor length = new HInvokeInterceptor(
         selector,
         const SourceString("length"),
         <HInstruction>[interceptor, receiver],
         getter: true);
-    length.propagatedType = HType.INTEGER;
+    types[length] = HType.INTEGER;
     node.block.addBefore(node, length);
 
     HBoundsCheck check = new HBoundsCheck(index, length);
     node.block.addBefore(node, check);
     return check;
   }
 
   HIntegerCheck insertIntegerCheck(HInstruction node, HInstruction value) {
     HIntegerCheck check = new HIntegerCheck(value);
     node.block.addBefore(node, check);
     Set<HInstruction> dominatedUsers = value.dominatedUsers(check);
     for (HInstruction user in dominatedUsers) {
       user.changeUse(value, check);
     }
     return check;
   }
 
   void visitIndex(HIndex node) {
-    if (!node.receiver.isIndexablePrimitive()) return;
+    if (!node.receiver.isIndexablePrimitive(types)) return;
     HInstruction index = node.index;
     if (index is HBoundsCheck) return;
-    if (!node.index.isInteger()) {
+    if (!node.index.isInteger(types)) {
       index = insertIntegerCheck(node, index);
     }
     index = insertBoundsCheck(node, node.receiver, index);
     node.changeUse(node.index, index);
   }
 
   void visitIndexAssign(HIndexAssign node) {
-    if (!node.receiver.isMutableArray()) return;
+    if (!node.receiver.isMutableArray(types)) return;
     HInstruction index = node.index;
     if (index is HBoundsCheck) return;
-    if (!node.index.isInteger()) {
+    if (!node.index.isInteger(types)) {
       index = insertIntegerCheck(node, index);
     }
     index = insertBoundsCheck(node, node.receiver, index);
     node.changeUse(node.index, index);
   }
 }
 
 class SsaDeadCodeEliminator extends HGraphVisitor implements OptimizationPhase {
+  final HTypeMap types;
   final String name = "SsaDeadCodeEliminator";
 
-  static bool isDeadCode(HInstruction instruction) {
-    return !instruction.hasSideEffects()
+  SsaDeadCodeEliminator(this.types);
+
+  bool isDeadCode(HInstruction instruction) {
+    return !instruction.hasSideEffects(types)
            && instruction.usedBy.isEmpty()
            && instruction is !HCheck
            && instruction is !HTypeGuard
            && !instruction.isControlFlow();
   }
 
   void visitGraph(HGraph graph) {
     visitPostDominatorTree(graph);
   }
 
@@ skipping 106 matching lines @@
       }
       phi.block.rewrite(phi, candidate);
       phi.block.removePhi(phi);
     }
   }
 }
 
 class SsaGlobalValueNumberer implements OptimizationPhase {
   final String name = "SsaGlobalValueNumberer";
   final Compiler compiler;
+  final HTypeMap types;
   final Set<int> visited;
 
   List<int> blockChangesFlags;
   List<int> loopChangesFlags;
 
-  SsaGlobalValueNumberer(this.compiler) : visited = new Set<int>();
+  SsaGlobalValueNumberer(this.compiler, this.types) : visited = new Set<int>();
 
   void visitGraph(HGraph graph) {
     computeChangesFlags(graph);
     moveLoopInvariantCode(graph);
     visitBasicBlock(graph.entry, new ValueSet());
   }
 
   void moveLoopInvariantCode(HGraph graph) {
     for (int i = graph.blocks.length - 1; i >= 0; i--) {
       HBasicBlock block = graph.blocks[i];
@@ skipping 105 matching lines @@
     // Run through all the basic blocks in the graph and fill in the
     // changes flags lists.
     for (int i = length - 1; i >= 0; i--) {
       final HBasicBlock block = graph.blocks[i];
       final int id = block.id;
 
       // Compute block changes flags for the block.
       int changesFlags = 0;
       HInstruction instruction = block.first;
       while (instruction !== null) {
-        instruction.prepareGvn();
+        instruction.prepareGvn(types);
         changesFlags |= instruction.getChangesFlags();
         instruction = instruction.next;
       }
       assert(blockChangesFlags[id] === null);
       blockChangesFlags[id] = changesFlags;
 
       // Loop headers are part of their loop, so update the loop
       // changes flags accordingly.
       if (block.isLoopHeader()) {
         loopChangesFlags[id] |= changesFlags;
@@ skipping 187 matching lines @@
     }
   }
 }
 
 
 // Base class for the handling of recompilation based on inferred
 // field types.
 class BaseRecompilationVisitor extends HBaseVisitor {
   final JavaScriptBackend backend;
   final WorkItem work;
+  final HTypeMap types;
   Compiler get compiler() => backend.compiler;
 
-  BaseRecompilationVisitor(this.backend, this.work);
+  BaseRecompilationVisitor(this.backend, this.work, this.types);
 
   abstract void handleFieldGet(HFieldGet node, HType type);
   abstract void handleFieldNumberOperation(HFieldGet field, HType type);
 
   // Checks if the binary invocation operates on a field and a
   // constant number. If it does [handleFieldNumberOperation] is
   // called with the field and the type inferred for the field so far.
   void checkFieldNumberOperation(HInvokeBinary node) {
     // Determine if one of the operands is an HFieldGet.
     HFieldGet field;
@@ skipping 49 matching lines @@
   }
 }
 
 
 // Visitor that registers candidates for recompilation.
 class SsaRegisterRecompilationCandidates
     extends BaseRecompilationVisitor implements OptimizationPhase {
   final String name = "SsaRegisterRecompileCandidates";
   HGraph graph;
 
-  SsaRegisterRecompilationCandidates(
-      JavaScriptBackend backend, WorkItem work) : super(backend, work);
+  SsaRegisterRecompilationCandidates(JavaScriptBackend backend,
+                                     WorkItem work,
+                                     HTypeMap types)
+      : super(backend, work, types);
 
   void visitGraph(HGraph visitee) {
     graph = visitee;
     if (compiler.phase == Compiler.PHASE_COMPILING) {
       visitDominatorTree(visitee);
     }
   }
 
   void handleFieldGet(HFieldGet node, HType type) {
     assert(compiler.phase == Compiler.PHASE_COMPILING);
     compiler.enqueuer.codegen.registerRecompilationCandidate(
         work.element);
   }
 
   void handleFieldNumberOperation(HFieldGet node, HType type) {
     assert(compiler.phase == Compiler.PHASE_COMPILING);
     compiler.enqueuer.codegen.registerRecompilationCandidate(
         work.element);
   }
 }
 
 
 // Visitor that sets the known or suspected type of fields during
 // recompilation.
 class SsaRecompilationFieldTypePropagator
     extends BaseRecompilationVisitor implements OptimizationPhase {
   final String name = "SsaRecompilationFieldTypePropagator";
   HGraph graph;
 
-  SsaRecompilationFieldTypePropagator(
-      JavaScriptBackend backend, WorkItem work) : super(backend, work);
+  SsaRecompilationFieldTypePropagator(JavaScriptBackend backend,
+                                      WorkItem work,
+                                      HTypeMap types)
+      : super(backend, work, types);
 
   void visitGraph(HGraph visitee) {
     graph = visitee;
     if (compiler.phase == Compiler.PHASE_RECOMPILING) {
       visitDominatorTree(visitee);
     }
   }
 
   void handleFieldGet(HFieldGet field, HType type) {
     assert(compiler.phase == Compiler.PHASE_RECOMPILING);
     if (!type.isConflicting()) {
       // If there are no invoked setters with this name, the union of
       // the types of the initializers and the setters is guaranteed
       // otherwise it is only speculative.
       Element element = field.element;
       assert(!element.isGenerativeConstructorBody());
       if (!compiler.codegenWorld.hasInvokedSetter(element, compiler)) {
         field.guaranteedType =
             type.union(backend.fieldSettersTypeSoFar(element));
       } else {
-        field.propagatedType =
-            type.union(backend.fieldSettersTypeSoFar(element));
+        types[field] = type.union(backend.fieldSettersTypeSoFar(element));
       }
     }
   }
 
   void handleFieldNumberOperation(HFieldGet field, HType type) {
     assert(compiler.phase == Compiler.PHASE_RECOMPILING);
     if (compiler.codegenWorld.hasInvokedSetter(field.element, compiler)) {
       // If there are invoked setters we don't know for sure
       // that the field will hold a value of the calculated
       // type, but the fact that the class itself sticks to
       // this type for the field is still a strong signal
       // indicating the expected type of the field.
-      field.propagatedType = type;
+      types[field] = type;
     } else {
       // If there are no invoked setters we know the type of
       // this field for sure.
       field.guaranteedType = type;
     }
   }
 }