Split World usage into open, inference, and closed world.

pkg/compiler/lib/src/ssa/builder.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 'dart:collection';
 
 import 'package:js_runtime/shared/embedded_names.dart';
 
 import '../closure.dart';
 import '../common.dart';
@@ skipping 536 matching lines @@
    *
    * However, inlining can only be performed when the target function can be
    * resolved statically. The defaults can therefore be included at this point.
    *
    * The [providedArguments] list contains first all positional arguments, then
    * the provided named arguments (the named arguments that are defined in the
    * [selector]) in a specific order (see [addDynamicSendArgumentsToList]).
    */
   List<HInstruction> completeDynamicSendArgumentsList(Selector selector,
       FunctionElement function, List<HInstruction> providedArguments) {
-    assert(selector.applies(function, compiler.world));
+    assert(selector.applies(function, compiler.closedWorld));
     FunctionSignature signature = function.functionSignature;
     List<HInstruction> compiledArguments = new List<HInstruction>(
         signature.parameterCount + 1); // Plus one for receiver.
 
     compiledArguments[0] = providedArguments[0]; // Receiver.
     int index = 1;
     for (; index <= signature.requiredParameterCount; index++) {
       compiledArguments[index] = providedArguments[index];
     }
     if (!signature.optionalParametersAreNamed) {
@@ skipping 73 matching lines @@
     bool meetsHardConstraints() {
       if (compiler.options.disableInlining) return false;
 
       assert(invariant(
           currentNode != null ? currentNode : element,
           selector != null ||
               Elements.isStaticOrTopLevel(element) ||
               element.isGenerativeConstructorBody,
           message: "Missing selector for inlining of $element."));
       if (selector != null) {
-        if (!selector.applies(function, compiler.world)) return false;
-        if (mask != null && !mask.canHit(function, selector, compiler.world)) {
+        if (!selector.applies(function, compiler.closedWorld)) return false;
+        if (mask != null &&
+            !mask.canHit(function, selector, compiler.closedWorld)) {
           return false;
         }
       }
 
       if (backend.isJsInterop(element)) return false;
 
       // Don't inline operator== methods if the parameter can be null.
       if (element.name == '==') {
         if (element.enclosingClass != coreClasses.objectClass &&
             providedArguments[1].canBeNull()) {
@@ skipping 224 matching lines @@
     return graph.addConstant(getConstantForNode(node), compiler);
   }
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: [functionElement] must be an implementation element.
    */
   HGraph buildMethod(FunctionElement functionElement) {
     assert(invariant(functionElement, functionElement.isImplementation));
-    graph.calledInLoop = compiler.world.isCalledInLoop(functionElement);
+    graph.calledInLoop = compiler.closedWorld.isCalledInLoop(functionElement);
     ast.FunctionExpression function = resolvedAst.node;
     assert(function != null);
     assert(elements.getFunctionDefinition(function) != null);
     openFunction(functionElement, function);
     String name = functionElement.name;
     if (backend.isJsInterop(functionElement)) {
       push(invokeJsInteropFunction(functionElement, parameters.values.toList(),
           sourceInformationBuilder.buildGeneric(function)));
       var value = pop();
       closeAndGotoExit(new HReturn(
@@ skipping 567 matching lines @@
         assert(invariant(
             member, isNativeUpgradeFactory || compiler.compilationFailed));
       } else {
         fields.add(member);
         DartType type = localsHandler.substInContext(member.type);
         constructorArguments.add(potentiallyCheckOrTrustType(value, type));
       }
     }, includeSuperAndInjectedMembers: true);
 
     InterfaceType type = classElement.thisType;
-    TypeMask ssaType =
-        new TypeMask.nonNullExact(classElement.declaration, compiler.world);
+    TypeMask ssaType = new TypeMask.nonNullExact(
+        classElement.declaration, compiler.closedWorld);
     List<DartType> instantiatedTypes;
     addInlinedInstantiation(type);
     if (!currentInlinedInstantiations.isEmpty) {
       instantiatedTypes = new List<DartType>.from(currentInlinedInstantiations);
     }
 
     HInstruction newObject;
     if (!isNativeUpgradeFactory) {
       newObject = new HCreate(
           classElement, constructorArguments, ssaType, instantiatedTypes);
@@ skipping 92 matching lines @@
         });
       }
 
       if (!isNativeUpgradeFactory && // TODO(13836): Fix inlining.
           tryInlineMethod(body, null, null, bodyCallInputs, function)) {
         pop();
       } else {
         HInvokeConstructorBody invoke = new HInvokeConstructorBody(
             body.declaration, bodyCallInputs, backend.nonNullType);
         invoke.sideEffects =
-            compiler.world.getSideEffectsOfElement(constructor);
+            compiler.closedWorld.getSideEffectsOfElement(constructor);
         add(invoke);
       }
     }
     if (inliningStack.isEmpty) {
       closeAndGotoExit(new HReturn(newObject,
           sourceInformationBuilder.buildImplicitReturn(functionElement)));
       return closeFunction();
     } else {
       localsHandler.updateLocal(returnLocal, newObject);
       return null;
@@ skipping 121 matching lines @@
   HInstruction buildTypeConversion(
       HInstruction original, DartType type, int kind) {
     if (type == null) return original;
     // GENERIC_METHODS: The following statement was added for parsing and
     // ignoring method type variables; must be generalized for full support of
     // generic methods.
     type = type.dynamifyMethodTypeVariableType;
     type = type.unaliased;
     assert(assertTypeInContext(type, original));
     if (type.isInterfaceType && !type.treatAsRaw) {
-      TypeMask subtype = new TypeMask.subtype(type.element, compiler.world);
+      TypeMask subtype =
+          new TypeMask.subtype(type.element, compiler.closedWorld);
       HInstruction representations = buildTypeArgumentRepresentations(type);
       add(representations);
       return new HTypeConversion.withTypeRepresentation(
           type, kind, subtype, original, representations);
     } else if (type.isTypeVariable) {
       TypeMask subtype = original.instructionType;
       HInstruction typeVariable = addTypeVariableReference(type);
       return new HTypeConversion.withTypeRepresentation(
           type, kind, subtype, original, typeVariable);
     } else if (type.isFunctionType) {
@@ skipping 20 matching lines @@
   HInstruction _trustType(HInstruction original, DartType type) {
     assert(compiler.options.trustTypeAnnotations);
     assert(type != null);
     type = localsHandler.substInContext(type);
     type = type.unaliased;
     if (type.isDynamic) return original;
     if (!type.isInterfaceType) return original;
     if (type.isObject) return original;
     // The type element is either a class or the void element.
     Element element = type.element;
-    TypeMask mask = new TypeMask.subtype(element, compiler.world);
+    TypeMask mask = new TypeMask.subtype(element, compiler.closedWorld);
     return new HTypeKnown.pinned(mask, original);
   }
 
   HInstruction _checkType(HInstruction original, DartType type, int kind) {
     assert(compiler.options.enableTypeAssertions);
     assert(type != null);
     type = localsHandler.substInContext(type);
     HInstruction other = buildTypeConversion(original, type, kind);
     registry?.registerTypeUse(new TypeUse.isCheck(type));
     return other;
@@ skipping 624 matching lines @@
 
     List<HInstruction> capturedVariables = <HInstruction>[];
     closureClassElement.closureFields.forEach((ClosureFieldElement field) {
       Local capturedLocal =
           nestedClosureData.getLocalVariableForClosureField(field);
       assert(capturedLocal != null);
       capturedVariables.add(localsHandler.readLocal(capturedLocal));
     });
 
     TypeMask type =
-        new TypeMask.nonNullExact(closureClassElement, compiler.world);
+        new TypeMask.nonNullExact(closureClassElement, compiler.closedWorld);
     push(new HCreate(closureClassElement, capturedVariables, type)
       ..sourceInformation = sourceInformationBuilder.buildCreate(node));
 
     Element methodElement = nestedClosureData.closureElement;
     registry?.registerInstantiatedClosure(methodElement);
   }
 
   visitFunctionDeclaration(ast.FunctionDeclaration node) {
     assert(isReachable);
     visit(node.function);
@@ skipping 251 matching lines @@
           graph.addDeferredConstant(value, prefix, sourceInformation, compiler);
     } else {
       instruction = graph.addConstant(value, compiler,
           sourceInformation: sourceInformation);
     }
     stack.add(instruction);
     // The inferrer may have found a better type than the constant
     // handler in the case of lists, because the constant handler
     // does not look at elements in the list.
     TypeMask type = TypeMaskFactory.inferredTypeForElement(field, compiler);
-    if (!type.containsAll(compiler.world) && !instruction.isConstantNull()) {
+    if (!type.containsAll(compiler.closedWorld) &&
+        !instruction.isConstantNull()) {
       // TODO(13429): The inferrer should know that an element
       // cannot be null.
       instruction.instructionType = type.nonNullable();
     }
   }
 
   @override
   void previsitDeferredAccess(ast.Send node, PrefixElement prefix, _) {
     generateIsDeferredLoadedCheckIfNeeded(prefix, node);
   }
@@ skipping 325 matching lines @@
       pushInvokeStatic(null, helper, inputs, typeMask: backend.boolType);
       HInstruction call = pop();
       return new HIs.variable(type, expression, call, backend.boolType);
     } else if (RuntimeTypes.hasTypeArguments(type)) {
       ClassElement element = type.element;
       Element helper = helpers.checkSubtype;
       HInstruction representations = buildTypeArgumentRepresentations(type);
       add(representations);
       js.Name operator = backend.namer.operatorIs(element);
       HInstruction isFieldName = addConstantStringFromName(operator);
-      HInstruction asFieldName = compiler.world.hasAnyStrictSubtype(element)
+      HInstruction asFieldName = compiler.closedWorld
+              .hasAnyStrictSubtype(element)
           ? addConstantStringFromName(backend.namer.substitutionName(element))
           : graph.addConstantNull(compiler);
       List<HInstruction> inputs = <HInstruction>[
         expression,
         isFieldName,
         representations,
         asFieldName
       ];
       pushInvokeStatic(node, helper, inputs, typeMask: backend.boolType);
       HInstruction call = pop();
       return new HIs.compound(type, expression, call, backend.boolType);
     } else {
       if (backend.hasDirectCheckFor(type)) {
         return new HIs.direct(type, expression, backend.boolType);
       }
       // The interceptor is not always needed.  It is removed by optimization
       // when the receiver type or tested type permit.
       return new HIs.raw(
           type, expression, invokeInterceptor(expression), backend.boolType);
     }
   }
 
   HInstruction buildFunctionType(FunctionType type) {
-    type.accept(new TypeBuilder(compiler.world), this);
+    type.accept(new TypeBuilder(compiler.closedWorld), this);
     return pop();
   }
 
   void addDynamicSendArgumentsToList(ast.Send node, List<HInstruction> list) {
     CallStructure callStructure = elements.getSelector(node).callStructure;
     if (callStructure.namedArgumentCount == 0) {
       addGenericSendArgumentsToList(node.arguments, list);
     } else {
       // Visit positional arguments and add them to the list.
       Link<ast.Node> arguments = node.arguments;
@@ skipping 596 matching lines @@
     push(buildInvokeSuper(Selectors.noSuchMethod_, element, inputs));
   }
 
   /// Generate a call to a super method or constructor.
   void generateSuperInvoke(ast.Send node, FunctionElement function,
       SourceInformation sourceInformation) {
     // TODO(5347): Try to avoid the need for calling [implementation] before
     // calling [makeStaticArgumentList].
     Selector selector = elements.getSelector(node);
     assert(invariant(
-        node, selector.applies(function.implementation, compiler.world),
+        node, selector.applies(function.implementation, compiler.closedWorld),
         message: "$selector does not apply to ${function.implementation}"));
     List<HInstruction> inputs = makeStaticArgumentList(
         selector.callStructure, node.arguments, function.implementation);
     push(buildInvokeSuper(selector, function, inputs, sourceInformation));
   }
 
   /// Access the value from the super [element].
   void handleSuperGet(ast.Send node, Element element) {
     Selector selector = elements.getSelector(node);
     SourceInformation sourceInformation =
@@ skipping 144 matching lines @@
   }
 
   void handleInvalidSuperInvoke(ast.Send node, ast.NodeList arguments) {
     Selector selector = elements.getSelector(node);
     List<HInstruction> inputs = <HInstruction>[];
     addGenericSendArgumentsToList(arguments.nodes, inputs);
     generateSuperNoSuchMethodSend(node, selector, inputs);
   }
 
   bool needsSubstitutionForTypeVariableAccess(ClassElement cls) {
-    ClassWorld classWorld = compiler.world;
+    ClassWorld classWorld = compiler.closedWorld;
     if (classWorld.isUsedAsMixin(cls)) return true;
 
-    return compiler.world.anyStrictSubclassOf(cls, (ClassElement subclass) {
+    return compiler.closedWorld.anyStrictSubclassOf(cls,
+        (ClassElement subclass) {
       return !rti.isTrivialSubstitution(subclass, cls);
     });
   }
 
   /**
    * Generate code to extract the type argument from the object.
    */
   HInstruction readTypeVariable(TypeVariableType variable,
       {SourceInformation sourceInformation}) {
     assert(sourceElement.isInstanceMember);
@@ skipping 161 matching lines @@
         Elements.isGrowableListConstructorCall(elements[send], send, compiler);
 
     TypeMask computeType(element) {
       Element originalElement = elements[send];
       if (isFixedListConstructorCall ||
           Elements.isFilledListConstructorCall(
               originalElement, send, compiler)) {
         isFixedList = true;
         TypeMask inferred =
             TypeMaskFactory.inferredForNode(sourceElement, send, compiler);
-        return inferred.containsAll(compiler.world)
+        return inferred.containsAll(compiler.closedWorld)
             ? backend.fixedArrayType
             : inferred;
       } else if (isGrowableListConstructorCall) {
         TypeMask inferred =
             TypeMaskFactory.inferredForNode(sourceElement, send, compiler);
-        return inferred.containsAll(compiler.world)
+        return inferred.containsAll(compiler.closedWorld)
             ? backend.extendableArrayType
             : inferred;
       } else if (Elements.isConstructorOfTypedArraySubclass(
           originalElement, compiler)) {
         isFixedList = true;
         TypeMask inferred =
             TypeMaskFactory.inferredForNode(sourceElement, send, compiler);
         ClassElement cls = element.enclosingClass;
         assert(backend.isNative(cls.thisType.element));
-        return inferred.containsAll(compiler.world)
-            ? new TypeMask.nonNullExact(cls.thisType.element, compiler.world)
+        return inferred.containsAll(compiler.closedWorld)
+            ? new TypeMask.nonNullExact(
+                cls.thisType.element, compiler.closedWorld)
             : inferred;
       } else if (element.isGenerativeConstructor) {
         ClassElement cls = element.enclosingClass;
         if (cls.isAbstract) {
           // An error will be thrown.
           return new TypeMask.nonNullEmpty();
         } else {
           return new TypeMask.nonNullExact(
-              cls.thisType.element, compiler.world);
+              cls.thisType.element, compiler.closedWorld);
         }
       } else {
         return TypeMaskFactory.inferredReturnTypeForElement(
             originalElement, compiler);
       }
     }
 
     Element constructor = elements[send];
     CallStructure callStructure = elements.getSelector(send).callStructure;
     ConstructorElement constructorDeclaration = constructor;
@@ skipping 603 matching lines @@
   void pushInvokeDynamic(ast.Node node, Selector selector, TypeMask mask,
       List<HInstruction> arguments,
       {SourceInformation sourceInformation}) {
     // We prefer to not inline certain operations on indexables,
     // because the constant folder will handle them better and turn
     // them into simpler instructions that allow further
     // optimizations.
     bool isOptimizableOperationOnIndexable(Selector selector, Element element) {
       bool isLength = selector.isGetter && selector.name == "length";
       if (isLength || selector.isIndex) {
-        return compiler.world.isSubtypeOf(
+        return compiler.closedWorld.isSubtypeOf(
             element.enclosingClass.declaration, helpers.jsIndexableClass);
       } else if (selector.isIndexSet) {
-        return compiler.world.isSubtypeOf(element.enclosingClass.declaration,
+        return compiler.closedWorld.isSubtypeOf(
+            element.enclosingClass.declaration,
             helpers.jsMutableIndexableClass);
       } else {
         return false;
       }
     }
 
     bool isOptimizableOperation(Selector selector, Element element) {
       ClassElement cls = element.enclosingClass;
       if (isOptimizableOperationOnIndexable(selector, element)) return true;
       if (!backend.interceptedClasses.contains(cls)) return false;
       if (selector.isOperator) return true;
       if (selector.isSetter) return true;
       if (selector.isIndex) return true;
       if (selector.isIndexSet) return true;
       if (element == helpers.jsArrayAdd ||
           element == helpers.jsArrayRemoveLast ||
           element == helpers.jsStringSplit) {
         return true;
       }
       return false;
     }
 
-    Element element = compiler.world.locateSingleElement(selector, mask);
+    Element element = compiler.closedWorld.locateSingleElement(selector, mask);
     if (element != null &&
         !element.isField &&
         !(element.isGetter && selector.isCall) &&
         !(element.isFunction && selector.isGetter) &&
         !isOptimizableOperation(selector, element)) {
       if (tryInlineMethod(element, selector, mask, arguments, node)) {
         return;
       }
     }
 
@@ skipping 126 matching lines @@
     // TODO(johnniwinther): Use [sourceInformation] instead of [location].
     if (tryInlineMethod(element, null, null, arguments, location,
         instanceType: instanceType)) {
       return;
     }
 
     if (typeMask == null) {
       typeMask =
           TypeMaskFactory.inferredReturnTypeForElement(element, compiler);
     }
-    bool targetCanThrow = !compiler.world.getCannotThrow(element);
+    bool targetCanThrow = !compiler.closedWorld.getCannotThrow(element);
     // TODO(5346): Try to avoid the need for calling [declaration] before
     var instruction;
     if (backend.isJsInterop(element)) {
       instruction =
           invokeJsInteropFunction(element, arguments, sourceInformation);
     } else {
       // creating an [HInvokeStatic].
       instruction = new HInvokeStatic(element.declaration, arguments, typeMask,
           targetCanThrow: targetCanThrow)
         ..sourceInformation = sourceInformation;
       if (currentInlinedInstantiations.isNotEmpty) {
         instruction.instantiatedTypes =
             new List<DartType>.from(currentInlinedInstantiations);
       }
-      instruction.sideEffects = compiler.world.getSideEffectsOfElement(element);
+      instruction.sideEffects =
+          compiler.closedWorld.getSideEffectsOfElement(element);
     }
     if (location == null) {
       push(instruction);
     } else {
       pushWithPosition(instruction, location);
     }
   }
 
   HInstruction buildInvokeSuper(
       Selector selector, Element element, List<HInstruction> arguments,
@@ skipping 13 matching lines @@
     TypeMask type;
     if (!element.isGetter && selector.isGetter) {
       type = TypeMaskFactory.inferredTypeForElement(element, compiler);
     } else {
       type = TypeMaskFactory.inferredReturnTypeForElement(element, compiler);
     }
     HInstruction instruction = new HInvokeSuper(element, currentNonClosureClass,
         selector, inputs, type, sourceInformation,
         isSetter: selector.isSetter || selector.isIndexSet);
     instruction.sideEffects =
-        compiler.world.getSideEffectsOfSelector(selector, null);
+        compiler.closedWorld.getSideEffectsOfSelector(selector, null);
     return instruction;
   }
 
   void handleComplexOperatorSend(
       ast.SendSet node, HInstruction receiver, Link<ast.Node> arguments) {
     HInstruction rhs;
     if (node.isPrefix || node.isPostfix) {
       rhs = graph.addConstantInt(1, compiler);
     } else {
       visit(arguments.head);
       assert(arguments.tail.isEmpty);
       rhs = pop();
     }
     visitBinarySend(
         receiver,
         rhs,
         elements.getOperatorSelectorInComplexSendSet(node),
         elements.getOperatorTypeMaskInComplexSendSet(node),
         node,
         sourceInformation:
             sourceInformationBuilder.buildGeneric(node.assignmentOperator));
   }
 
   void handleSuperSendSet(ast.SendSet node) {
     Element element = elements[node];
     List<HInstruction> setterInputs = <HInstruction>[];
     void generateSuperSendSet() {
       Selector setterSelector = elements.getSelector(node);
       if (Elements.isUnresolved(element) ||
-          !setterSelector.applies(element, compiler.world)) {
+          !setterSelector.applies(element, compiler.closedWorld)) {
         generateSuperNoSuchMethodSend(node, setterSelector, setterInputs);
         pop();
       } else {
         add(buildInvokeSuper(setterSelector, element, setterInputs));
       }
     }
 
     if (identical(node.assignmentOperator.source, '=')) {
       addDynamicSendArgumentsToList(node, setterInputs);
       generateSuperSendSet();
@@ skipping 952 matching lines @@
     visit(node.expression);
     HInstruction yielded = pop();
     add(new HYield(yielded, node.hasStar));
   }
 
   visitAwait(ast.Await node) {
     visit(node.expression);
     HInstruction awaited = pop();
     // TODO(herhut): Improve this type.
     push(new HAwait(awaited,
-        new TypeMask.subclass(coreClasses.objectClass, compiler.world)));
+        new TypeMask.subclass(coreClasses.objectClass, compiler.closedWorld)));
   }
 
   visitTypeAnnotation(ast.TypeAnnotation node) {
     reporter.internalError(node, 'Visiting type annotation in SSA builder.');
   }
 
   visitVariableDefinitions(ast.VariableDefinitions node) {
     assert(isReachable);
     for (Link<ast.Node> link = node.definitions.nodes;
         !link.isEmpty;
@@ skipping 40 matching lines @@
         visit(link.head);
         inputs.add(pop());
       }
       instruction = buildLiteralList(inputs);
       add(instruction);
       instruction = setRtiIfNeeded(instruction, node);
     }
 
     TypeMask type =
         TypeMaskFactory.inferredForNode(sourceElement, node, compiler);
-    if (!type.containsAll(compiler.world)) instruction.instructionType = type;
+    if (!type.containsAll(compiler.closedWorld))
+      instruction.instructionType = type;
     stack.add(instruction);
   }
 
   visitConditional(ast.Conditional node) {
     SsaBranchBuilder brancher = new SsaBranchBuilder(this, compiler, node);
     brancher.handleConditional(() => visit(node.condition),
         () => visit(node.thenExpression), () => visit(node.elseExpression));
   }
 
   visitStringInterpolation(ast.StringInterpolation node) {
@@ skipping 79 matching lines @@
         [expression, graph.addConstantNull(compiler)]);
     streamIterator = pop();
 
     void buildInitializer() {}
 
     HInstruction buildCondition() {
       Selector selector = Selectors.moveNext;
       TypeMask mask = elements.getMoveNextTypeMask(node);
       pushInvokeDynamic(node, selector, mask, [streamIterator]);
       HInstruction future = pop();
-      push(new HAwait(future,
-          new TypeMask.subclass(coreClasses.objectClass, compiler.world)));
+      push(new HAwait(
+          future,
+          new TypeMask.subclass(
+              coreClasses.objectClass, compiler.closedWorld)));
       return popBoolified();
     }
 
     void buildBody() {
       Selector call = Selectors.current;
       TypeMask callMask = elements.getCurrentTypeMask(node);
       pushInvokeDynamic(node, call, callMask, [streamIterator]);
 
       ast.Node identifier = node.declaredIdentifier;
       Element variable = elements.getForInVariable(node);
@@ skipping 16 matching lines @@
     }
 
     void buildUpdate() {}
     ;
 
     buildProtectedByFinally(() {
       handleLoop(
           node, buildInitializer, buildCondition, buildUpdate, buildBody);
     }, () {
       pushInvokeDynamic(node, Selectors.cancel, null, [streamIterator]);
-      push(new HAwait(pop(),
-          new TypeMask.subclass(coreClasses.objectClass, compiler.world)));
+      push(new HAwait(
+          pop(),
+          new TypeMask.subclass(
+              coreClasses.objectClass, compiler.closedWorld)));
       pop();
     });
   }
 
   visitSyncForIn(ast.SyncForIn node) {
     // The 'get iterator' selector for this node has the inferred receiver type.
     // If the receiver supports JavaScript indexing we generate an indexing loop
     // instead of allocating an iterator object.
 
     // This scheme recognizes for-in on direct lists.  It does not recognize all
     // uses of ArrayIterator.  They still occur when the receiver is an Iterable
     // with a `get iterator` method that delegate to another Iterable and the
     // method is inlined.  We would require full scalar replacement in that
     // case.
 
     TypeMask mask = elements.getIteratorTypeMask(node);
 
-    ClassWorld classWorld = compiler.world;
+    ClassWorld classWorld = compiler.closedWorld;
     if (mask != null &&
         mask.satisfies(helpers.jsIndexableClass, classWorld) &&
         // String is indexable but not iterable.
         !mask.satisfies(helpers.jsStringClass, classWorld)) {
       return buildSyncForInIndexable(node, mask);
     }
     buildSyncForInIterator(node);
   }
 
   buildSyncForInIterator(ast.SyncForIn node) {
@@ skipping 257 matching lines @@
     }
 
     // If rti is needed and the map literal has no type parameters,
     // 'constructor' is a static function that forwards the call to the factory
     // constructor without type parameters.
     assert(constructor is ConstructorElement || constructor is FunctionElement);
 
     // The instruction type will always be a subtype of the mapLiteralClass, but
     // type inference might discover a more specific type, or find nothing (in
     // dart2js unit tests).
-    TypeMask mapType =
-        new TypeMask.nonNullSubtype(helpers.mapLiteralClass, compiler.world);
+    TypeMask mapType = new TypeMask.nonNullSubtype(
+        helpers.mapLiteralClass, compiler.closedWorld);
     TypeMask returnTypeMask =
         TypeMaskFactory.inferredReturnTypeForElement(constructor, compiler);
     TypeMask instructionType =
-        mapType.intersection(returnTypeMask, compiler.world);
+        mapType.intersection(returnTypeMask, compiler.closedWorld);
 
     addInlinedInstantiation(expectedType);
     pushInvokeStatic(node, constructor, inputs,
         typeMask: instructionType, instanceType: expectedType);
     removeInlinedInstantiation(expectedType);
   }
 
   visitLiteralMapEntry(ast.LiteralMapEntry node) {
     visit(node.value);
     visit(node.key);
@@ skipping 807 matching lines @@
     if (expression.canBePrimitive(compiler)) {
       append(stringify(node, expression));
       return;
     }
 
     // If the `toString` method is guaranteed to return a string we can call it
     // directly.
     Selector selector = Selectors.toString_;
     TypeMask type = TypeMaskFactory.inferredTypeForSelector(
         selector, expression.instructionType, compiler);
-    if (type.containsOnlyString(compiler.world)) {
+    if (type.containsOnlyString(compiler.closedWorld)) {
       builder.pushInvokeDynamic(node, selector, expression.instructionType,
           <HInstruction>[expression]);
       append(builder.pop());
       return;
     }
 
     append(stringify(node, expression));
   }
 
   void visitStringInterpolation(ast.StringInterpolation node) {
@@ skipping 294 matching lines @@
   const _LoopTypeVisitor();
   int visitNode(ast.Node node) => HLoopBlockInformation.NOT_A_LOOP;
   int visitWhile(ast.While node) => HLoopBlockInformation.WHILE_LOOP;
   int visitFor(ast.For node) => HLoopBlockInformation.FOR_LOOP;
   int visitDoWhile(ast.DoWhile node) => HLoopBlockInformation.DO_WHILE_LOOP;
   int visitAsyncForIn(ast.AsyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSyncForIn(ast.SyncForIn node) => HLoopBlockInformation.FOR_IN_LOOP;
   int visitSwitchStatement(ast.SwitchStatement node) =>
       HLoopBlockInformation.SWITCH_CONTINUE_LOOP;
 }