Make ClosedWorld a forTesting property of ResolutionWorldBuilder.

R=sigmund@google.com

Review-Url: https://codereview.chromium.org/2580353002 .

pkg/compiler/lib/src/compiler.dart

@@ -78,7 +78,7 @@ import 'universe/world_impact.dart'
         WorldImpactBuilder,
         WorldImpactBuilderImpl;
 import 'util/util.dart' show Link, Setlet;
-import 'world.dart' show ClosedWorld, ClosedWorldRefiner, OpenWorld, WorldImpl;
+import 'world.dart' show ClosedWorld, ClosedWorldRefiner, WorldImpl;
 
 typedef Backend MakeBackendFuncion(Compiler compiler);
 
@@ -89,7 +89,6 @@ abstract class Compiler implements LibraryLoaderListener {
   Measurer get measurer;
 
   final IdGenerator idGenerator = new IdGenerator();
-  WorldImpl get _world => resolverWorld.openWorld;
   Types types;
   _CompilerCoreTypes _coreTypes;
   CompilerDiagnosticReporter _reporter;
@@ -276,13 +275,6 @@ abstract class Compiler implements LibraryLoaderListener {
     tasks.addAll(backend.tasks);
   }
 
-  /// The closed world after resolution and inference.
-  ClosedWorld get closedWorld {
-    assert(invariant(CURRENT_ELEMENT_SPANNABLE, _world.isClosed,
-        message: "Closed world not computed yet."));
-    return _world;
-  }
-
   /// Creates the backend.
   ///
   /// Override this to mock the backend for testing.
@@ -704,6 +696,9 @@ abstract class Compiler implements LibraryLoaderListener {
         assert(mainFunction != null);
 
         ClosedWorldRefiner closedWorldRefiner = closeResolution();
+        // TODO(johnniwinther): Make [ClosedWorld] a property of
+        // [ClosedWorldRefiner].
+        ClosedWorld closedWorld = resolverWorld.closedWorldForTesting;
 
         reporter.log('Inferring types...');
         globalInference.runGlobalTypeInference(

pkg/compiler/lib/src/js_backend/enqueuer.dart

@@ -86,7 +86,8 @@ class CodegenEnqueuer extends EnqueuerImpl {
   CodegenWorldBuilder get universe => _universe;
 
   // TODO(johnniwinther): Remove these hacks:
-  ClosedWorld get _world => _backend.compiler.closedWorld;
+  ClosedWorld get _world =>
+      _backend.compiler.resolverWorld.closedWorldForTesting;
   DumpInfoTask get _dumpInfoTask => _backend.compiler.dumpInfoTask;
 
   bool get queueIsEmpty => _queue.isEmpty;

pkg/compiler/lib/src/universe/world_builder.dart

@@ -172,6 +172,11 @@ abstract class ResolutionWorldBuilder implements WorldBuilder {
   /// The [OpenWorld] being created by this world builder.
   // TODO(johnniwinther): Merge this with [ResolutionWorldBuilder].
   OpenWorld get openWorld;
+
+  /// The closed world computed by this world builder.
+  ///
+  /// This is only available after the world builder has been closed.
+  ClosedWorld get closedWorldForTesting;
 }
 
 /// The type and kind of an instantiation registered through
@@ -425,7 +430,7 @@ class ResolutionWorldBuilderImpl implements ResolutionWorldBuilder {
   /// and classes.
   bool useInstantiationMap = false;
 
-  OpenWorld _openWorld;
+  WorldImpl _openWorld;
 
   final Backend _backend;
   final Resolution _resolution;
@@ -443,6 +448,14 @@ class ResolutionWorldBuilderImpl implements ResolutionWorldBuilder {
 
   OpenWorld get openWorld => _openWorld;
 
+  ClosedWorld get closedWorldForTesting {
+    if (!_openWorld.isClosed) {
+      throw new SpannableAssertionFailure(
+          NO_LOCATION_SPANNABLE, "The world builder has not yet been closed.");
+    }
+    return _openWorld;
+  }
+
   /// All directly instantiated classes, that is, classes with a generative
   /// constructor that has been called directly and not only through a
   /// super-call.

tests/compiler/dart2js/assert_message_throw_test.dart

@@ -59,7 +59,7 @@ main() {
         memorySourceFiles: {'main.dart': SOURCE},
         options: [Flags.enableCheckedMode, Flags.enableAssertMessage]);
     Compiler compiler = result.compiler;
-    ClosedWorld closedWorld = compiler.closedWorld;
+    ClosedWorld closedWorld = compiler.resolverWorld.closedWorldForTesting;
 
     void check(String methodName, TypeMask expectedReturnType) {
       Element element = compiler.mainApp.find(methodName);

tests/compiler/dart2js/concrete_type_inference_test.dart

@@ -20,21 +20,24 @@ void checkPrintType(String expression, checkType(closedWorld, type)) {
   asyncTest(() => compileAndFind('main() { print($expression); }', 'print',
           (compiler, printElement) {
         var parameter = printElement.functionSignature.requiredParameters.first;
-        checkType(compiler.closedWorld, _typeOf(compiler, parameter));
+        checkType(compiler.resolverWorld.closedWorldForTesting,
+            _typeOf(compiler, parameter));
       }));
 
   asyncTest(() =>
       compileAndFind('main() { var x = print; print($expression); }', 'print',
           (compiler, printElement) {
         var parameter = printElement.functionSignature.requiredParameters.first;
-        checkType(compiler.closedWorld, _typeOf(compiler, parameter));
+        checkType(compiler.resolverWorld.closedWorldForTesting,
+            _typeOf(compiler, parameter));
       }));
 
   asyncTest(() => compileAndFind(
           'main() { print($expression); print($expression); }', 'print',
           (compiler, printElement) {
         var parameter = printElement.functionSignature.requiredParameters.first;
-        checkType(compiler.closedWorld, _typeOf(compiler, parameter));
+        checkType(compiler.resolverWorld.closedWorldForTesting,
+            _typeOf(compiler, parameter));
       }));
 }
 
@@ -68,7 +71,7 @@ void testOptionalParameters() {
     var firstParameter = fiskElement.functionSignature.requiredParameters[0];
     var secondParameter = fiskElement.functionSignature.optionalParameters[0];
     var thirdParameter = fiskElement.functionSignature.optionalParameters[1];
-    var commonMasks = compiler.closedWorld.commonMasks;
+    var commonMasks = compiler.resolverWorld.closedWorldForTesting.commonMasks;
     Expect.identical(commonMasks.uint31Type, _typeOf(compiler, firstParameter));
     Expect.identical(commonMasks.nullType, _typeOf(compiler, secondParameter));
     Expect.identical(commonMasks.nullType, _typeOf(compiler, thirdParameter));

tests/compiler/dart2js/dump_info_test.dart

@@ -104,7 +104,7 @@ jsonTest(String program, JsonTaking testFn) async {
   var dumpTask = compiler.dumpInfoTask;
 
   StringBuffer sb = new StringBuffer();
-  dumpTask.dumpInfoJson(sb, compiler.closedWorld);
+  dumpTask.dumpInfoJson(sb, compiler.resolverWorld.closedWorldForTesting);
   String json = sb.toString();
   Map<String, dynamic> map = JSON.decode(json);
 

tests/compiler/dart2js/expect_annotations_test.dart

@@ -52,7 +52,7 @@ main() {
     CompilationResult result =
         await runCompiler(memorySourceFiles: MEMORY_SOURCE_FILES);
     Compiler compiler = result.compiler;
-    ClosedWorld closedWorld = compiler.closedWorld;
+    ClosedWorld closedWorld = compiler.resolverWorld.closedWorldForTesting;
     Expect.isFalse(compiler.compilationFailed, 'Unsuccessful compilation');
     JavaScriptBackend backend = compiler.backend;
     Expect.isNotNull(backend.annotations.expectNoInlineClass,

tests/compiler/dart2js/gvn_dynamic_field_get_test.dart

@@ -36,7 +36,7 @@ main() {
         var element = cls.lookupLocalMember(name);
         Expect.isNotNull(element);
         Selector selector = new Selector.getter(new PublicName(name));
-        Expect.isFalse(
-            compiler.closedWorld.hasAnyUserDefinedGetter(selector, null));
+        Expect.isFalse(compiler.resolverWorld.closedWorldForTesting
+            .hasAnyUserDefinedGetter(selector, null));
       }));
 }

tests/compiler/dart2js/kernel/closed_world_test.dart

@@ -136,7 +136,7 @@ main(List<String> args) {
       }
       return true;
     }, verbose: arguments.verbose);
-    checkClosedWorlds(compiler.closedWorld, closedWorld,
+    checkClosedWorlds(compiler.resolverWorld.closedWorldForTesting, closedWorld,
         verbose: arguments.verbose);
   });
 }

tests/compiler/dart2js/patch_test.dart

@@ -974,7 +974,7 @@ Future testPatchAndSelector() async {
       runCompiler: true,
       analyzeOnly: true);
   compiler.closeResolution();
-  ClosedWorld world = compiler.closedWorld;
+  ClosedWorld world = compiler.resolverWorld.closedWorldForTesting;
 
   ClassElement cls = ensure(
       compiler, "A", compiler.commonElements.coreLibrary.find,

tests/compiler/dart2js/related_types.dart

@@ -36,7 +36,6 @@ main(List<String> arguments) async {
 /// Check all loaded libraries in [compiler] for unrelated types.
 void checkRelatedTypes(Compiler compiler) {
   compiler.closeResolution();
-  compiler.closedWorld;
   for (LibraryElement library in compiler.libraryLoader.libraries) {
     checkLibraryElement(compiler, library);
   }
@@ -78,7 +77,7 @@ class RelatedTypesChecker extends TraversalVisitor<DartType, dynamic> {
       : this.resolvedAst = resolvedAst,
         super(resolvedAst.elements);
 
-  ClosedWorld get world => compiler.closedWorld;
+  ClosedWorld get world => compiler.resolverWorld.closedWorldForTesting;
 
   CoreClasses get coreClasses => compiler.coreClasses;
 

tests/compiler/dart2js/serialization/model_test_helper.dart

@@ -98,8 +98,8 @@ Future checkModels(Uri entryPoint,
     checkResolutionEnqueuers(compilerNormal.enqueuer.resolution,
         compilerDeserialized.enqueuer.resolution,
         verbose: verbose);
-    checkClosedWorlds(
-        compilerNormal.closedWorld, compilerDeserialized.closedWorld,
+    checkClosedWorlds(compilerNormal.resolverWorld.closedWorldForTesting,
+        compilerDeserialized.resolverWorld.closedWorldForTesting,
         verbose: verbose);
     checkBackendInfo(compilerNormal, compilerDeserialized, verbose: verbose);
   });

tests/compiler/dart2js/simple_inferrer_callers_test.dart

@@ -40,7 +40,7 @@ void main() {
   var compiler = compilerFor(TEST, uri, analyzeOnly: true);
   asyncTest(() => compiler.run(uri).then((_) {
         ClosedWorldRefiner closedWorldRefiner = compiler.closeResolution();
-        ClosedWorld closedWorld = compiler.closedWorld;
+        ClosedWorld closedWorld = compiler.resolverWorld.closedWorldForTesting;
         var inferrer =
             new MyInferrer(compiler, closedWorld, closedWorldRefiner);
         compiler.globalInference.typesInferrerInternal = inferrer;

tests/compiler/dart2js/simple_inferrer_no_such_method_test.dart

@@ -174,7 +174,7 @@ test1() async {
   Uri uri = new Uri(scheme: 'source');
   var compiler = compilerFor(TEST1, uri);
   await compiler.run(uri);
-  var closedWorld = compiler.closedWorld;
+  var closedWorld = compiler.resolverWorld.closedWorldForTesting;
   checkReturn(compiler, 'test1', closedWorld.commonMasks.uint31Type);
   checkReturn(
       compiler, 'test2', closedWorld.commonMasks.dynamicType.nonNullable());
@@ -190,7 +190,7 @@ test2() async {
   Uri uri = new Uri(scheme: 'source');
   var compiler = compilerFor(TEST2, uri);
   await compiler.run(uri);
-  var closedWorld = compiler.closedWorld;
+  var closedWorld = compiler.resolverWorld.closedWorldForTesting;
   checkReturn(compiler, 'test1', closedWorld.commonMasks.mapType.nonNullable());
   checkReturn(compiler, 'test2', closedWorld.commonMasks.mapType);
   checkReturn(compiler, 'test3', closedWorld.commonMasks.mapType);
@@ -209,7 +209,7 @@ test3() async {
   Uri uri = new Uri(scheme: 'source');
   var compiler = compilerFor(TEST3, uri);
   await compiler.run(uri);
-  var closedWorld = compiler.closedWorld;
+  var closedWorld = compiler.resolverWorld.closedWorldForTesting;
   checkReturn(compiler, 'test1', const TypeMask.nonNullEmpty());
   checkReturn(compiler, 'test2', closedWorld.commonMasks.mapType);
   checkReturn(compiler, 'test3', closedWorld.commonMasks.mapType);
@@ -222,7 +222,7 @@ test4() async {
   Uri uri = new Uri(scheme: 'source');
   var compiler = compilerFor(TEST4, uri);
   await compiler.run(uri);
-  var closedWorld = compiler.closedWorld;
+  var closedWorld = compiler.resolverWorld.closedWorldForTesting;
   checkReturn(compiler, 'test1', const TypeMask.nonNullEmpty());
   checkReturn(compiler, 'test2', closedWorld.commonMasks.mapType);
   checkReturn(compiler, 'test3', closedWorld.commonMasks.mapType);

tests/compiler/dart2js/type_combination_test.dart

@@ -102,7 +102,7 @@ class RuleSet {
 }
 
 void testUnion(MockCompiler compiler) {
-  ClosedWorld closedWorld = compiler.closedWorld;
+  ClosedWorld closedWorld = compiler.resolverWorld.closedWorldForTesting;
   RuleSet ruleSet = new RuleSet(
       'union', (t1, t2) => simplify(t1.union(t2, closedWorld), closedWorld));
   rule(type1, type2, result) => ruleSet.rule(type1, type2, result);
@@ -416,7 +416,7 @@ void testUnion(MockCompiler compiler) {
 void testIntersection(MockCompiler compiler) {
   JavaScriptBackend backend = compiler.backend;
   BackendHelpers helpers = backend.helpers;
-  ClosedWorld closedWorld = compiler.closedWorld;
+  ClosedWorld closedWorld = compiler.resolverWorld.closedWorldForTesting;
   RuleSet ruleSet =
       new RuleSet('intersection', (t1, t2) => t1.intersection(t2, closedWorld));
   rule(type1, type2, result) => ruleSet.rule(type1, type2, result);
@@ -726,7 +726,7 @@ void testIntersection(MockCompiler compiler) {
 }
 
 void testRegressions(MockCompiler compiler) {
-  ClosedWorld closedWorld = compiler.closedWorld;
+  ClosedWorld closedWorld = compiler.resolverWorld.closedWorldForTesting;
   TypeMask nonNullPotentialString =
       new TypeMask.nonNullSubtype(patternClass, closedWorld);
   Expect.equals(potentialString,
@@ -760,7 +760,7 @@ void main() {
         .registerTypeUse(new TypeUse.instantiation(patternImplClass.rawType));
     compiler.enqueuer.resolution.applyImpact(impactBuilder);
     compiler.closeResolution();
-    ClosedWorld closedWorld = compiler.closedWorld;
+    ClosedWorld closedWorld = compiler.resolverWorld.closedWorldForTesting;
 
     // Grab hold of a supertype for String so we can produce potential
     // string types.

tests/compiler/dart2js/type_mask_disjoint_test.dart

@@ -36,7 +36,7 @@ main() {
 
 Uri uri = new Uri(scheme: 'source');
 var compiler = compilerFor(CODE, uri);
-var world = compiler.closedWorld;
+var world = compiler.resolverWorld.closedWorldForTesting;
 
 main() {
   asyncTest(() => compiler.run(uri).then((_) {

tests/compiler/dart2js/type_mask_test.dart

@@ -22,7 +22,7 @@ main() {
   Uri uri = new Uri(scheme: 'source');
   var compiler = compilerFor(CODE, uri);
   compiler.closeResolution();
-  var closedWorld = compiler.closedWorld;
+  var closedWorld = compiler.resolverWorld.closedWorldForTesting;
 
   asyncTest(() => compiler.run(uri).then((_) {
         var classA = findElement(compiler, 'A');

tests/compiler/dart2js/type_test_helper.dart

@@ -142,6 +142,6 @@ class TypeEnvironment {
   }
 
   ClosedWorld get closedWorld {
-    return compiler.closedWorld;
+    return compiler.resolverWorld.closedWorldForTesting;
   }
 }