Even less reliance on Compiler.closedWorld

pkg/compiler/lib/src/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.
 
 import '../common/codegen.dart' show CodegenRegistry, CodegenWorkItem;
 import '../common/names.dart' show Selectors;
 import '../common/tasks.dart' show CompilerTask;
 import '../compiler.dart' show Compiler;
 import '../constants/constant_system.dart';
 import '../constants/values.dart';
-import '../core_types.dart' show CoreClasses;
+import '../core_types.dart' show CommonElements, CoreClasses;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../js/js.dart' as js;
 import '../js_backend/backend_helpers.dart' show BackendHelpers;
 import '../js_backend/js_backend.dart';
 import '../native/native.dart' as native;
 import '../tree/dartstring.dart' as ast;
 import '../types/types.dart';
 import '../universe/selector.dart' show Selector;
 import '../universe/side_effects.dart' show SideEffects;
@@ skipping 110 matching lines @@
 /// of identifying gvn-able lengths and mis-identifies some unions of fixed
 /// length indexables (see TODO) as not fixed length.
 bool isFixedLength(mask, Compiler compiler) {
   ClosedWorld closedWorld = compiler.closedWorld;
   JavaScriptBackend backend = compiler.backend;
   if (mask.isContainer && mask.length != null) {
     // A container on which we have inferred the length.
     return true;
   }
   // TODO(sra): Recognize any combination of fixed length indexables.
-  if (mask.containsOnly(backend.helpers.jsFixedArrayClass) ||
-      mask.containsOnly(backend.helpers.jsUnmodifiableArrayClass) ||
+  if (mask.containsOnly(closedWorld.backendClasses.fixedListImplementation) ||
+      mask.containsOnly(closedWorld.backendClasses.constListImplementation) ||
       mask.containsOnlyString(closedWorld) ||
-      backend.isTypedArray(mask)) {
+      closedWorld.commonMasks.isTypedArray(mask)) {
     return true;
   }
   return false;
 }
 
 /**
  * If both inputs to known operations are available execute the operation at
  * compile-time.
  */
 class SsaInstructionSimplifier extends HBaseVisitor
     implements OptimizationPhase {
   // We don't produce constant-folded strings longer than this unless they have
   // a single use.  This protects against exponentially large constant folded
   // strings.
   static const MAX_SHARED_CONSTANT_FOLDED_STRING_LENGTH = 512;
 
   final String name = "SsaInstructionSimplifier";
   final JavaScriptBackend backend;
   final ConstantSystem constantSystem;
   final CodegenRegistry registry;
   HGraph graph;
   Compiler get compiler => backend.compiler;
   final SsaOptimizerTask optimizer;
 
   SsaInstructionSimplifier(
       this.constantSystem, this.backend, this.optimizer, this.registry);
 
-  CoreClasses get coreClasses => compiler.coreClasses;
-
   ClosedWorld get closedWorld => compiler.closedWorld;
 
+  CommonElements get commonElements => closedWorld.commonElements;
+
   BackendHelpers get helpers => backend.helpers;
 
+  GlobalTypeInferenceResults get globalInferenceResults =>
+      compiler.globalInference.results;
+
   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);
@@ skipping 251 matching lines @@
     return node;
   }
 
   HInstruction visitInvokeDynamicMethod(HInvokeDynamicMethod node) {
     propagateConstantValueToUses(node);
     if (node.isInterceptedCall) {
       HInstruction folded = handleInterceptedCall(node);
       if (folded != node) return folded;
     }
 
-    TypeMask receiverType = node.getDartReceiver(compiler).instructionType;
+    TypeMask receiverType = node.getDartReceiver(closedWorld).instructionType;
     Element element =
-        compiler.closedWorld.locateSingleElement(node.selector, receiverType);
+        closedWorld.locateSingleElement(node.selector, receiverType);
     // TODO(ngeoffray): Also fold if it's a getter or variable.
     if (element != null &&
         element.isFunction
         // If we found out that the only target is an implicitly called
         // [:noSuchMethod:] we just ignore it.
         &&
         node.selector.applies(element)) {
       MethodElement method = element;
 
       if (backend.isNative(method)) {
@@ skipping 12 matching lines @@
     }
 
     // Replace method calls through fields with a closure call on the value of
     // the field. This usually removes the demand for the call-through stub and
     // makes the field load available to further optimization, e.g. LICM.
 
     if (element != null &&
         element.isField &&
         element.name == node.selector.name) {
       FieldElement field = element;
-      if (!backend.isNative(field) && !node.isCallOnInterceptor(compiler)) {
-        HInstruction receiver = node.getDartReceiver(compiler);
-        TypeMask type = TypeMaskFactory.inferredTypeForElement(field, compiler);
+      if (!backend.isNative(field) && !node.isCallOnInterceptor(closedWorld)) {
+        HInstruction receiver = node.getDartReceiver(closedWorld);
+        TypeMask type = TypeMaskFactory.inferredTypeForElement(
+            field, globalInferenceResults);
         HInstruction load = new HFieldGet(field, receiver, type);
         node.block.addBefore(node, load);
         Selector callSelector = new Selector.callClosureFrom(node.selector);
         List<HInstruction> inputs = <HInstruction>[load]
           ..addAll(node.inputs.skip(node.isInterceptedCall ? 2 : 1));
         HInstruction closureCall =
             new HInvokeClosure(callSelector, inputs, node.instructionType)
               ..sourceInformation = node.sourceInformation;
         node.block.addAfter(load, closureCall);
         return closureCall;
@@ skipping 49 matching lines @@
       }
     });
 
     if (!canInline) return null;
 
     // Strengthen instruction type from annotations to help optimize
     // dependent instructions.
     native.NativeBehavior nativeBehavior =
         backend.getNativeMethodBehavior(method);
     TypeMask returnType =
-        TypeMaskFactory.fromNativeBehavior(nativeBehavior, compiler);
+        TypeMaskFactory.fromNativeBehavior(nativeBehavior, closedWorld);
     HInvokeDynamicMethod result =
         new HInvokeDynamicMethod(node.selector, node.mask, inputs, returnType);
     result.element = method;
     return result;
   }
 
   HInstruction visitBoundsCheck(HBoundsCheck node) {
     HInstruction index = node.index;
     if (index.isInteger(closedWorld)) return node;
     if (index.isConstant()) {
@@ skipping 157 matching lines @@
   }
 
   HInstruction visitIs(HIs node) {
     DartType type = node.typeExpression;
     Element element = type.element;
 
     if (!node.isRawCheck) {
       return node;
     } else if (type.isTypedef) {
       return node;
-    } else if (element == coreClasses.functionClass) {
+    } else if (element == commonElements.functionClass) {
       return node;
     }
 
     if (type.isObject || type.treatAsDynamic) {
       return graph.addConstantBool(true, compiler);
     }
 
     HInstruction expression = node.expression;
     if (expression.isInteger(closedWorld)) {
-      if (element == coreClasses.intClass ||
-          element == coreClasses.numClass ||
-          Elements.isNumberOrStringSupertype(element, compiler)) {
+      if (element == commonElements.intClass ||
+          element == commonElements.numClass ||
+          Elements.isNumberOrStringSupertype(element, commonElements)) {
         return graph.addConstantBool(true, compiler);
-      } else if (element == coreClasses.doubleClass) {
+      } else if (element == commonElements.doubleClass) {
         // We let the JS semantics decide for that check. Currently
         // the code we emit will always return true.
         return node;
       } else {
         return graph.addConstantBool(false, compiler);
       }
     } else if (expression.isDouble(closedWorld)) {
-      if (element == coreClasses.doubleClass ||
-          element == coreClasses.numClass ||
-          Elements.isNumberOrStringSupertype(element, compiler)) {
+      if (element == commonElements.doubleClass ||
+          element == commonElements.numClass ||
+          Elements.isNumberOrStringSupertype(element, commonElements)) {
         return graph.addConstantBool(true, compiler);
-      } else if (element == coreClasses.intClass) {
+      } else if (element == commonElements.intClass) {
         // We let the JS semantics decide for that check. Currently
         // the code we emit will return true for a double that can be
         // represented as a 31-bit integer and for -0.0.
         return node;
       } else {
         return graph.addConstantBool(false, compiler);
       }
     } else if (expression.isNumber(closedWorld)) {
-      if (element == coreClasses.numClass) {
+      if (element == commonElements.numClass) {
         return graph.addConstantBool(true, compiler);
       } else {
         // We cannot just return false, because the expression may be of
         // type int or double.
       }
     } else if (expression.canBePrimitiveNumber(closedWorld) &&
-        element == coreClasses.intClass) {
+        element == commonElements.intClass) {
       // We let the JS semantics decide for that check.
       return node;
       // We need the [:hasTypeArguments:] check because we don't have
       // the notion of generics in the backend. For example, [:this:] in
       // a class [:A<T>:], is currently always considered to have the
       // raw type.
     } else if (!RuntimeTypes.hasTypeArguments(type)) {
       TypeMask expressionMask = expression.instructionType;
       assert(TypeMask.assertIsNormalized(expressionMask, closedWorld));
-      TypeMask typeMask = (element == coreClasses.nullClass)
+      TypeMask typeMask = (element == commonElements.nullClass)
           ? new TypeMask.subtype(element, closedWorld)
           : new TypeMask.nonNullSubtype(element, closedWorld);
       if (expressionMask.union(typeMask, closedWorld) == typeMask) {
         return graph.addConstantBool(true, compiler);
       } else if (expressionMask.isDisjoint(typeMask, closedWorld)) {
         return graph.addConstantBool(false, compiler);
       }
     }
     return node;
   }
@@ skipping 40 matching lines @@
     HInstruction input = node.checkedInput;
     TypeMask inputType = input.instructionType;
     return inputType.isInMask(checkedType, closedWorld) ? input : node;
   }
 
   HInstruction removeCheck(HCheck node) => node.checkedInput;
 
   FieldElement findConcreteFieldForDynamicAccess(
       HInstruction receiver, Selector selector) {
     TypeMask receiverType = receiver.instructionType;
-    return compiler.closedWorld.locateSingleField(selector, receiverType);
+    return closedWorld.locateSingleField(selector, receiverType);
   }
 
   HInstruction visitFieldGet(HFieldGet node) {
     if (node.isNullCheck) return node;
     var receiver = node.receiver;
     if (node.element == helpers.jsIndexableLength) {
       if (graph.allocatedFixedLists.contains(receiver)) {
         // TODO(ngeoffray): checking if the second input is an integer
         // should not be necessary but it currently makes it easier for
         // other optimizations to reason about a fixed length constructor
@@ skipping 50 matching lines @@
     }
     return node;
   }
 
   HInstruction visitInvokeDynamicGetter(HInvokeDynamicGetter node) {
     propagateConstantValueToUses(node);
     if (node.isInterceptedCall) {
       HInstruction folded = handleInterceptedCall(node);
       if (folded != node) return folded;
     }
-    HInstruction receiver = node.getDartReceiver(compiler);
+    HInstruction receiver = node.getDartReceiver(closedWorld);
     FieldElement field =
         findConcreteFieldForDynamicAccess(receiver, node.selector);
     if (field != null) return directFieldGet(receiver, field);
 
     if (node.element == null) {
       MemberElement element = closedWorld.locateSingleElement(
           node.selector, receiver.instructionType);
       if (element != null && element.name == node.selector.name) {
         node.element = element;
         if (element.isFunction) {
           // A property extraction getter, aka a tear-off.
           node.sideEffects.clearAllDependencies();
           node.sideEffects.clearAllSideEffects();
           node.setUseGvn(); // We don't care about identity of tear-offs.
         }
       }
     }
     return node;
   }
 
   HInstruction directFieldGet(HInstruction receiver, FieldElement field) {
     bool isAssignable = !closedWorld.fieldNeverChanges(field);
 
     TypeMask type;
     if (backend.isNative(field.enclosingClass)) {
       type = TypeMaskFactory.fromNativeBehavior(
-          backend.getNativeFieldLoadBehavior(field), compiler);
+          backend.getNativeFieldLoadBehavior(field), closedWorld);
     } else {
-      type = TypeMaskFactory.inferredTypeForElement(field, compiler);
+      type =
+          TypeMaskFactory.inferredTypeForElement(field, globalInferenceResults);
     }
 
     return new HFieldGet(field, receiver, type, isAssignable: isAssignable);
   }
 
   HInstruction visitInvokeDynamicSetter(HInvokeDynamicSetter node) {
     if (node.isInterceptedCall) {
       HInstruction folded = handleInterceptedCall(node);
       if (folded != node) return folded;
     }
 
-    HInstruction receiver = node.getDartReceiver(compiler);
+    HInstruction receiver = node.getDartReceiver(closedWorld);
     FieldElement field =
         findConcreteFieldForDynamicAccess(receiver, node.selector);
     if (field == null || !field.isAssignable) return node;
     // Use `node.inputs.last` in case the call follows the interceptor calling
     // convention, but is not a call on an interceptor.
     HInstruction value = node.inputs.last;
     if (compiler.options.enableTypeAssertions) {
       DartType type = field.type;
       if (!type.treatAsRaw ||
           type.isTypeVariable ||
@@ skipping 116 matching lines @@
 
     HInstruction tryToString() {
       // If the `toString` method is guaranteed to return a string we can call
       // it directly. Keep the stringifier for primitives (since they have fast
       // path code in the stringifier) and for classes requiring interceptors
       // (since SsaInstructionSimplifier runs after SsaSimplifyInterceptors).
       if (input.canBePrimitive(closedWorld)) return null;
       if (input.canBeNull()) return null;
       Selector selector = Selectors.toString_;
       TypeMask toStringType = TypeMaskFactory.inferredTypeForSelector(
-          selector, input.instructionType, compiler);
+          selector, input.instructionType, globalInferenceResults);
       if (!toStringType.containsOnlyString(closedWorld)) return null;
       // All intercepted classes extend `Interceptor`, so if the receiver can't
       // be a class extending `Interceptor` then it can be called directly.
       if (new TypeMask.nonNullSubclass(helpers.jsInterceptorClass, closedWorld)
           .isDisjoint(input.instructionType, closedWorld)) {
         var inputs = <HInstruction>[input, input]; // [interceptor, receiver].
         HInstruction result = new HInvokeDynamicMethod(
             selector,
             input.instructionType, // receiver mask.
             inputs,
@@ skipping 322 matching lines @@
         return hole.isPositional && hole.nameOrPosition == 0;
       }
     }
     return false;
   }
 
   /// Returns whether the next throwing instruction that may have side
   /// effects after [instruction], throws [NoSuchMethodError] on the
   /// same receiver of [instruction].
   bool hasFollowingThrowingNSM(HInstruction instruction) {
-    HInstruction receiver = instruction.getDartReceiver(compiler);
+    HInstruction receiver = instruction.getDartReceiver(closedWorld);
     HInstruction current = instruction.next;
     do {
-      if ((current.getDartReceiver(compiler) == receiver) &&
+      if ((current.getDartReceiver(closedWorld) == receiver) &&
           current.canThrow()) {
         return true;
       }
       if (current is HForeignCode &&
           templateThrowsNSMonNull(current, receiver)) {
         return true;
       }
       if (current.canThrow() || current.sideEffects.hasSideEffects()) {
         return false;
       }
@@ skipping 23 matching lines @@
   }
 
   bool isTrivialDeadStoreReceiver(HInstruction instruction) {
     // For an allocation, if all the loads are dead (awaiting removal after
     // SsaLoadElimination) and the only other uses are stores, then the
     // allocation does not escape which makes all the stores dead too.
     bool isDeadUse(HInstruction use) {
       if (use is HFieldSet) {
         // The use must be the receiver.  Even if the use is also the argument,
         // i.e.  a.x = a, the store is still dead if all other uses are dead.
-        if (use.getDartReceiver(compiler) == instruction) return true;
+        if (use.getDartReceiver(closedWorld) == instruction) return true;
       } else if (use is HFieldGet) {
-        assert(use.getDartReceiver(compiler) == instruction);
+        assert(use.getDartReceiver(closedWorld) == instruction);
         if (isDeadCode(use)) return true;
       }
       return false;
     }
 
     return instruction.isAllocation &&
         instruction.isPure() &&
         trivialDeadStoreReceivers.putIfAbsent(
             instruction, () => instruction.usedBy.every(isDeadUse));
   }
 
   bool isTrivialDeadStore(HInstruction instruction) {
     return instruction is HFieldSet &&
-        isTrivialDeadStoreReceiver(instruction.getDartReceiver(compiler));
+        isTrivialDeadStoreReceiver(instruction.getDartReceiver(closedWorld));
   }
 
   bool isDeadCode(HInstruction instruction) {
     if (!instruction.usedBy.isEmpty) return false;
     if (isTrivialDeadStore(instruction)) return true;
     if (instruction.sideEffects.hasSideEffects()) return false;
     if (instruction.canThrow() &&
         instruction.onlyThrowsNSM() &&
         hasFollowingThrowingNSM(instruction)) {
       return true;
@@ skipping 708 matching lines @@
  * location.
  */
 class SsaLoadElimination extends HBaseVisitor implements OptimizationPhase {
   final Compiler compiler;
   final String name = "SsaLoadElimination";
   MemorySet memorySet;
   List<MemorySet> memories;
 
   SsaLoadElimination(this.compiler);
 
+  ClosedWorld get closedWorld => compiler.closedWorld;
+
   void visitGraph(HGraph graph) {
     memories = new List<MemorySet>(graph.blocks.length);
     List<HBasicBlock> blocks = graph.blocks;
     for (int i = 0; i < blocks.length; i++) {
       HBasicBlock block = blocks[i];
       visitBasicBlock(block);
       if (block.successors.isNotEmpty && block.successors[0].isLoopHeader()) {
         // We've reached the ending block of a loop. Iterate over the
         // blocks of the loop again to take values that flow from that
         // ending block into account.
         for (int j = block.successors[0].id; j <= block.id; j++) {
           visitBasicBlock(blocks[j]);
         }
       }
     }
   }
 
   void visitBasicBlock(HBasicBlock block) {
     if (block.predecessors.length == 0) {
       // Entry block.
-      memorySet = new MemorySet(compiler);
+      memorySet = new MemorySet(closedWorld);
     } else if (block.predecessors.length == 1 &&
         block.predecessors[0].successors.length == 1) {
       // No need to clone, there is no other successor for
       // `block.predecessors[0]`, and this block has only one
       // predecessor. Since we are not going to visit
       // `block.predecessors[0]` again, we can just re-use its
       // [memorySet].
       memorySet = memories[block.predecessors[0].id];
     } else if (block.predecessors.length == 1) {
       // Clone the memorySet of the predecessor, because it is also used
@@ skipping 13 matching lines @@
     while (instruction != null) {
       HInstruction next = instruction.next;
       instruction.accept(this);
       instruction = next;
     }
   }
 
   void visitFieldGet(HFieldGet instruction) {
     if (instruction.isNullCheck) return;
     MemberElement element = instruction.element;
-    HInstruction receiver = instruction.getDartReceiver(compiler).nonCheck();
+    HInstruction receiver = instruction.getDartReceiver(closedWorld).nonCheck();
     HInstruction existing = memorySet.lookupFieldValue(element, receiver);
     if (existing != null) {
       instruction.block.rewriteWithBetterUser(instruction, existing);
       instruction.block.remove(instruction);
     } else {
       memorySet.registerFieldValue(element, receiver, instruction);
     }
   }
 
   void visitFieldSet(HFieldSet instruction) {
-    HInstruction receiver = instruction.getDartReceiver(compiler).nonCheck();
+    HInstruction receiver = instruction.getDartReceiver(closedWorld).nonCheck();
     memorySet.registerFieldValueUpdate(
         instruction.element, receiver, instruction.inputs.last);
   }
 
   void visitCreate(HCreate instruction) {
     memorySet.registerAllocation(instruction);
     if (shouldTrackInitialValues(instruction)) {
       int argumentIndex = 0;
       instruction.element.forEachInstanceField((_, FieldElement member) {
         if (compiler.elementHasCompileTimeError(member)) return;
@@ skipping 119 matching lines @@
 
 /**
  * Holds values of memory places.
  *
  * Generally, values that name a place (a receiver) have type refinements and
  * other checks removed to ensure that checks and type refinements do not
  * confuse aliasing.  Values stored into a memory place keep the type
  * refinements to help further optimizations.
  */
 class MemorySet {
-  final Compiler compiler;
+  final ClosedWorld closedWorld;
 
   /**
    * Maps a field to a map of receiver to value.
    */
   final Map<Element, Map<HInstruction, HInstruction>> fieldValues =
       <Element, Map<HInstruction, HInstruction>>{};
 
   /**
    * Maps a receiver to a map of keys to value.
    */
   final Map<HInstruction, Map<HInstruction, HInstruction>> keyedValues =
       <HInstruction, Map<HInstruction, HInstruction>>{};
 
   /**
    * Set of objects that we know don't escape the current function.
    */
   final Setlet<HInstruction> nonEscapingReceivers = new Setlet<HInstruction>();
 
-  MemorySet(this.compiler);
-
-  JavaScriptBackend get backend => compiler.backend;
+  MemorySet(this.closedWorld);
 
   /**
    * Returns whether [first] and [second] always alias to the same object.
    */
   bool mustAlias(HInstruction first, HInstruction second) {
     return first == second;
   }
 
   /**
    * Returns whether [first] and [second] may alias to the same object.
    */
   bool mayAlias(HInstruction first, HInstruction second) {
     if (mustAlias(first, second)) return true;
     if (isConcrete(first) && isConcrete(second)) return false;
     if (nonEscapingReceivers.contains(first)) return false;
     if (nonEscapingReceivers.contains(second)) return false;
     // Typed arrays of different types might have a shared buffer.
     if (couldBeTypedArray(first) && couldBeTypedArray(second)) return true;
     return !first.instructionType
-        .isDisjoint(second.instructionType, compiler.closedWorld);
+        .isDisjoint(second.instructionType, closedWorld);
   }
 
   bool isFinal(Element element) {
-    return compiler.closedWorld.fieldNeverChanges(element);
+    return closedWorld.fieldNeverChanges(element);
   }
 
   bool isConcrete(HInstruction instruction) {
     return instruction is HCreate ||
         instruction is HConstant ||
         instruction is HLiteralList;
   }
 
   bool couldBeTypedArray(HInstruction receiver) {
-    JavaScriptBackend backend = compiler.backend;
-    return backend.couldBeTypedArray(receiver.instructionType);
+    return closedWorld.commonMasks.couldBeTypedArray(receiver.instructionType);
   }
 
   /**
    * Returns whether [receiver] escapes the current function.
    */
   bool escapes(HInstruction receiver) {
     assert(receiver == null || receiver == receiver.nonCheck());
     return !nonEscapingReceivers.contains(receiver);
   }
 
   void registerAllocation(HInstruction instruction) {
     assert(instruction == instruction.nonCheck());
     nonEscapingReceivers.add(instruction);
   }
 
   /**
    * Sets `receiver.element` to contain [value]. Kills all potential places that
    * may be affected by this update.
    */
   void registerFieldValueUpdate(
       MemberElement element, HInstruction receiver, HInstruction value) {
     assert(receiver == null || receiver == receiver.nonCheck());
-    if (backend.isNative(element)) {
+    if (closedWorld.backendClasses.isNative(element)) {
       return; // TODO(14955): Remove this restriction?
     }
     // [value] is being set in some place in memory, we remove it from
     // the non-escaping set.
     nonEscapingReceivers.remove(value.nonCheck());
     Map<HInstruction, HInstruction> map =
         fieldValues.putIfAbsent(element, () => <HInstruction, HInstruction>{});
     map.forEach((key, value) {
       if (mayAlias(receiver, key)) map[key] = null;
     });
     map[receiver] = value;
   }
 
   /**
    * Registers that `receiver.element` is now [value].
    */
   void registerFieldValue(
       MemberElement element, HInstruction receiver, HInstruction value) {
     assert(receiver == null || receiver == receiver.nonCheck());
-    if (backend.isNative(element)) {
+    if (closedWorld.backendClasses.isNative(element)) {
       return; // TODO(14955): Remove this restriction?
     }
     Map<HInstruction, HInstruction> map =
         fieldValues.putIfAbsent(element, () => <HInstruction, HInstruction>{});
     map[receiver] = value;
   }
 
   /**
    * Returns the value stored in `receiver.element`. Returns `null` if we don't
    * know.
@@ skipping 89 matching lines @@
 
   /**
    * Returns null if either [first] or [second] is null. Otherwise
    * returns [first] if [first] and [second] are equal. Otherwise
    * creates or re-uses a phi in [block] that holds [first] and [second].
    */
   HInstruction findCommonInstruction(HInstruction first, HInstruction second,
       HBasicBlock block, int predecessorIndex) {
     if (first == null || second == null) return null;
     if (first == second) return first;
-    TypeMask phiType = second.instructionType
-        .union(first.instructionType, compiler.closedWorld);
+    TypeMask phiType =
+        second.instructionType.union(first.instructionType, closedWorld);
     if (first is HPhi && first.block == block) {
       HPhi phi = first;
       phi.addInput(second);
       phi.instructionType = phiType;
       return phi;
     } else {
       HPhi phi = new HPhi.noInputs(null, phiType);
       block.addPhi(phi);
       // Previous predecessors had the same input. A phi must have
       // the same number of inputs as its block has predecessors.
       for (int i = 0; i < predecessorIndex; i++) {
         phi.addInput(first);
       }
       phi.addInput(second);
       return phi;
     }
   }
 
   /**
    * Returns the intersection between [this] and [other].
    */
   MemorySet intersectionFor(
       MemorySet other, HBasicBlock block, int predecessorIndex) {
-    MemorySet result = new MemorySet(compiler);
+    MemorySet result = new MemorySet(closedWorld);
     if (other == null) {
       // This is the first visit to a loop header ([other] is `null` because we
       // have not visited the back edge). Copy the nonEscapingReceivers that are
       // guaranteed to survive the loop because they are not escaped before
       // method exit.
       // TODO(sra): We should do a proper dataflow to find the maximal
       // nonEscapingReceivers (a variant of Available-Expressions), which must
       // converge before we edit the program in [findCommonInstruction].
       for (HInstruction instruction in nonEscapingReceivers) {
         bool isNonEscapingUse(HInstruction use) {
@@ skipping 44 matching lines @@
         result.nonEscapingReceivers.add(receiver);
       }
     });
     return result;
   }
 
   /**
    * Returns a copy of [this].
    */
   MemorySet clone() {
-    MemorySet result = new MemorySet(compiler);
+    MemorySet result = new MemorySet(closedWorld);
 
     fieldValues.forEach((element, values) {
       result.fieldValues[element] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     keyedValues.forEach((receiver, values) {
       result.keyedValues[receiver] =
           new Map<HInstruction, HInstruction>.from(values);
     });
 
     result.nonEscapingReceivers.addAll(nonEscapingReceivers);
     return result;
   }
 }