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

tests/compiler/dart2js/serialization/model_test_helper.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 dart2js.serialization_model_test;
 
 import 'dart:async';
 import 'dart:io';
 import 'package:async_helper/async_helper.dart';
 import 'package:expect/expect.dart';
@@ skipping 59 matching lines @@
   String id = index != null ? '$index: ' : '';
   String title = '${id}${testDescription}';
   Compiler compilerNormal = await measure(
       title, 'compile normal', () async {
     Compiler compilerNormal = compilerFor(
         memorySourceFiles: sourceFiles,
         options: [Flags.analyzeOnly]);
     compilerNormal.resolution.retainCachesForTesting = true;
     await compilerNormal.run(entryPoint);
     compilerNormal.phase = Compiler.PHASE_DONE_RESOLVING;
-    compilerNormal.world.populate();
+    compilerNormal.openWorld.populate();
     compilerNormal.backend.onResolutionComplete();
     compilerNormal.deferredLoadTask.onResolutionComplete(
         compilerNormal.mainFunction);
     return compilerNormal;
   });
 
   Compiler compilerDeserialized = await measure(
       title, 'compile deserialized', () async {
     Compiler compilerDeserialized = compilerFor(
         memorySourceFiles: sourceFiles,
         resolutionInputs: resolutionInputs,
         options: [Flags.analyzeOnly]);
     compilerDeserialized.resolution.retainCachesForTesting = true;
     await compilerDeserialized.run(entryPoint);
     compilerDeserialized.phase = Compiler.PHASE_DONE_RESOLVING;
-    compilerDeserialized.world.populate();
+    compilerDeserialized.openWorld.populate();
     compilerDeserialized.backend.onResolutionComplete();
     compilerDeserialized.deferredLoadTask.onResolutionComplete(
         compilerDeserialized.mainFunction);
     return compilerDeserialized;
   });
 
   return measure(title, 'check models', () async {
     checkAllImpacts(
         compilerNormal, compilerDeserialized,
         verbose: verbose);
@@ skipping 26 matching lines @@
         areElementsEquivalent,
         onSameElement: (a, b) {
           checkElements(
               compilerNormal, compilerDeserialized, a, b, verbose: verbose);
         },
         verbose: verbose);
 
     checkClassHierarchyNodes(
         compilerNormal,
         compilerDeserialized,
-        compilerNormal.world.getClassHierarchyNode(
+        compilerNormal.closedWorld.getClassHierarchyNode(
             compilerNormal.coreClasses.objectClass),
-        compilerDeserialized.world.getClassHierarchyNode(
+        compilerDeserialized.closedWorld.getClassHierarchyNode(
             compilerDeserialized.coreClasses.objectClass),
         verbose: verbose);
 
     Expect.equals(compilerNormal.enabledInvokeOn,
         compilerDeserialized.enabledInvokeOn,
         "Compiler.enabledInvokeOn mismatch");
     Expect.equals(compilerNormal.enabledFunctionApply,
         compilerDeserialized.enabledFunctionApply,
         "Compiler.enabledFunctionApply mismatch");
     Expect.equals(compilerNormal.enabledRuntimeType,
@@ skipping 123 matching lines @@
 
   checkElementOutputUnits(compiler1, compiler2, element1, element2);
 }
 
 void checkMixinUses(
     Compiler compiler1, Compiler compiler2,
     ClassElement class1, ClassElement class2,
     {bool verbose: false}) {
 
   checkSets(
-      compiler1.world.mixinUsesOf(class1),
-      compiler2.world.mixinUsesOf(class2),
+      compiler1.closedWorld.mixinUsesOf(class1),
+      compiler2.closedWorld.mixinUsesOf(class2),
       "Mixin uses of $class1 vs $class2",
       areElementsEquivalent,
       verbose: verbose);
 
 }
 
 void checkClassHierarchyNodes(
     Compiler compiler1,
     Compiler compiler2,
     ClassHierarchyNode node1, ClassHierarchyNode node2,
@@ skipping 23 matching lines @@
         checkClassHierarchyNodes(compiler1, compiler2,
             child, other, verbose: verbose);
         found = true;
         break;
       }
     }
     if (!found) {
       if (child.isInstantiated) {
         print('Missing subclass ${child.cls} of ${node1.cls} '
             'in ${node2.directSubclasses}');
-        print(compiler1.world.dump(
+        print(compiler1.closedWorld.dump(
             verbose ? compiler1.coreClasses.objectClass : node1.cls));
-        print(compiler2.world.dump(
+        print(compiler2.closedWorld.dump(
             verbose ? compiler2.coreClasses.objectClass : node2.cls));
       }
       Expect.isFalse(child.isInstantiated,
           'Missing subclass ${child.cls} of ${node1.cls} in '
               '${node2.directSubclasses}');
     }
   }
   checkMixinUses(compiler1, compiler2, node1.cls, node2.cls, verbose: verbose);
 }
 
@@ skipping 60 matching lines @@
     OutputUnit outputUnit1, OutputUnit outputUnit2, String message) {
   if (outputUnit1 == null && outputUnit2 == null) return;
   check(outputUnit1, outputUnit2,
       'OutputUnit.isMainOutput $message',
       outputUnit1.isMainOutput, outputUnit2.isMainOutput);
   checkSetEquivalence(outputUnit1, outputUnit2,
       'OutputUnit.imports $message',
       outputUnit1.imports, outputUnit2.imports,
       (a, b) => areElementsEquivalent(a.declaration, b.declaration));
 }