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

tests/compiler/dart2js/type_combination_test.dart

Index: tests/compiler/dart2js/type_combination_test.dart
diff --git a/tests/compiler/dart2js/type_combination_test.dart b/tests/compiler/dart2js/type_combination_test.dart
index 5c72f356a3d45f37ab798eceab96b9ae43b1b669..84e1c349eb4984f111d167f0ca6b2f54aab16f80 100644
--- a/tests/compiler/dart2js/type_combination_test.dart
+++ b/tests/compiler/dart2js/type_combination_test.dart
@@ -103,7 +103,7 @@ class RuleSet {
 
 void testUnion(MockCompiler compiler) {
   RuleSet ruleSet = new RuleSet('union',
-      (t1, t2) => simplify(t1.union(t2, compiler.world), compiler));
+      (t1, t2) => simplify(t1.union(t2, compiler.closedWorld), compiler));
   rule(type1, type2, result) => ruleSet.rule(type1, type2, result);
   check(type1, type2, predicate) => ruleSet.check(type1, type2, predicate);
 
@@ -416,7 +416,7 @@ void testIntersection(MockCompiler compiler) {
   JavaScriptBackend backend = compiler.backend;
   BackendHelpers helpers = backend.helpers;
   RuleSet ruleSet = new RuleSet('intersection',
-      (t1, t2) => t1.intersection(t2, compiler.world));
+      (t1, t2) => t1.intersection(t2, compiler.closedWorld));
   rule(type1, type2, result) => ruleSet.rule(type1, type2, result);
 
   rule(emptyType, emptyType, emptyType);
@@ -557,9 +557,9 @@ void testIntersection(MockCompiler compiler) {
   rule(jsIndexable, nonPrimitive1, emptyType);
   rule(jsIndexable, nonPrimitive2, emptyType);
   rule(jsIndexable, potentialArray, new TypeMask.nonNullSubtype(
-      helpers.jsArrayClass, compiler.world));
+      helpers.jsArrayClass, compiler.closedWorld));
   rule(jsIndexable, potentialString, new TypeMask.nonNullSubtype(
-      helpers.jsStringClass, compiler.world));
+      helpers.jsStringClass, compiler.closedWorld));
   rule(jsIndexable, jsBooleanOrNull, emptyType);
   rule(jsIndexable, jsNumberOrNull, emptyType);
   rule(jsIndexable, jsIntegerOrNull, emptyType);
@@ -725,10 +725,10 @@ void testIntersection(MockCompiler compiler) {
 
 void testRegressions(MockCompiler compiler) {
   TypeMask nonNullPotentialString = new TypeMask.nonNullSubtype(
-      patternClass, compiler.world);
+      patternClass, compiler.closedWorld);
   Expect.equals(
       potentialString, jsStringOrNull.union(
-          nonNullPotentialString, compiler.world));
+          nonNullPotentialString, compiler.closedWorld));
 }
 
 void main() {
@@ -739,7 +739,7 @@ void main() {
     """);
     JavaScriptBackend backend = compiler.backend;
     BackendHelpers helpers = backend.helpers;
-    World world = compiler.world;
+    World world = compiler.closedWorld;
     helpers.interceptorsLibrary.forEachLocalMember((element) {
       if (element.isClass) {
         element.ensureResolved(compiler.resolution);
@@ -764,7 +764,7 @@ void main() {
         patternImplClass.rawType,
         compiler.enqueuer.resolution,
         compiler.globalDependencies);
-    compiler.world.populate();
+    compiler.openWorld.populate();
 
     // Grab hold of a supertype for String so we can produce potential
     // string types.