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

tests/compiler/dart2js/world_test.dart

 // Copyright (c) 2015, 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.
 
 library world_test;
 
 import 'package:expect/expect.dart';
 import 'package:async_helper/async_helper.dart';
 import 'type_test_helper.dart';
 import 'package:compiler/src/common.dart';
@@ skipping 26 matching lines @@
         new A();
         new B();
         new C();
         new D();
         new E();
         new F();
         new G();
       }
       """,
       useMockCompiler: false);
-  ClassWorld classWorld = env.compiler.world;
+  ClassWorld classWorld = env.compiler.closedWorld;
 
   ClassElement Object_ = env.getElement("Object");
   ClassElement A = env.getElement("A");
   ClassElement B = env.getElement("B");
   ClassElement C = env.getElement("C");
   ClassElement D = env.getElement("D");
   ClassElement E = env.getElement("E");
   ClassElement F = env.getElement("F");
   ClassElement G = env.getElement("G");
   ClassElement X = env.getElement("X");
 
   void checkClasses(
       String property,
       ClassElement cls,
       Iterable<ClassElement> foundClasses,
       List<ClassElement> expectedClasses,
       {bool exact: true}) {
 
     for (ClassElement expectedClass in expectedClasses) {
       Expect.isTrue(foundClasses.contains(expectedClass),
           "Expect $expectedClass in '$property' on $cls. "
           "Found:\n ${foundClasses.join('\n ')}\n"
-          "${env.compiler.world.dump(cls)}");
+          "${env.compiler.closedWorld.dump(cls)}");
     }
     if (exact) {
       Expect.equals(expectedClasses.length, foundClasses.length,
           "Unexpected classes "
           "${foundClasses.where((c) => !expectedClasses.contains(c))} "
           "in '$property' on $cls.\n"
-          "${env.compiler.world.dump(cls)}");
+          "${env.compiler.closedWorld.dump(cls)}");
     }
   }
 
   void check(
       String property,
       ClassElement cls,
       Iterable<ClassElement> foundClasses,
       List<ClassElement> expectedClasses,
       {bool exact: true,
        void forEach(ClassElement cls, ForEachFunction f),
        int getCount(ClassElement cls)}) {
     checkClasses(property, cls, foundClasses, expectedClasses, exact: exact);
 
     if (forEach != null) {
       List<ClassElement> visited = <ClassElement>[];
       forEach(cls, (ClassElement c) {
         visited.add(c);
       });
       checkClasses(
           'forEach($property)', cls, visited, expectedClasses, exact: exact);
     }
 
     if (getCount != null && exact) {
       int count = getCount(cls);
       Expect.equals(expectedClasses.length, count,
           "Unexpected class count in '$property' on $cls.\n"
-          "${env.compiler.world.dump(cls)}");
+          "${env.compiler.closedWorld.dump(cls)}");
     }
 
   }
 
   void testSubclasses(
       ClassElement cls,
       List<ClassElement> expectedClasses,
       {bool exact: true}) {
     check(
       'subclassesOf',
@@ skipping 135 matching lines @@
         new D2();
         new E3();
         new F1();
         new F2();
         new G2();
         new G3();
         new H4();
       }
       """,
       useMockCompiler: false);
-  ClassWorld classWorld = env.compiler.world;
+  ClassWorld classWorld = env.compiler.closedWorld;
 
   check(String name,
       {bool hasStrictSubtype,
        bool hasOnlySubclasses}) {
     ClassElement cls = env.getElement(name);
     Expect.equals(hasStrictSubtype, classWorld.hasAnyStrictSubtype(cls),
         "Unexpected hasAnyStrictSubtype property on $cls.");
     Expect.equals(hasOnlySubclasses, classWorld.hasOnlySubclasses(cls),
         "Unexpected hasOnlySubclasses property on $cls.");
   }
@@ skipping 45 matching lines @@
   check("G3", hasStrictSubtype: false, hasOnlySubclasses: true);
   check("G4", hasStrictSubtype: false, hasOnlySubclasses: true);
 
   // class H4 extends H2 with H extends H1 extends H instantiated
   check("H", hasStrictSubtype: true, hasOnlySubclasses: true);
   check("H1", hasStrictSubtype: true, hasOnlySubclasses: true);
   check("H2", hasStrictSubtype: true, hasOnlySubclasses: true);
   check("H3", hasStrictSubtype: false, hasOnlySubclasses: true);
   check("H4", hasStrictSubtype: false, hasOnlySubclasses: true);
 }