Make closedWorld a property of ClosedWorldRefiner.

pkg/compiler/lib/src/universe/world_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.
 
 library universe;
 
 import 'dart:collection';
 
 import '../cache_strategy.dart';
 import '../common.dart';
@@ skipping 480 matching lines @@
         this.cacheStrategy = cacheStrategy,
         alreadyPopulated = cacheStrategy.newSet() {
     _allFunctions = new FunctionSetBuilder();
   }
 
   Iterable<ClassElement> get processedClasses => _processedClasses.keys
       .where((cls) => _processedClasses[cls].isInstantiated);
 
   CommonElements get commonElements => _resolution.commonElements;
 
   ClosedWorld get closedWorldForTesting {

[Siggi Cherem (dart-lang), 2017/01/03 17:46:08]

do we still need this for testing, or should we be able to use the closedWorld
property you just added?

[Johnni Winther, 2017/01/04 09:11:20]

We still need it (kernel/closed_world_test). The ClosedWorldRefiner shouldn't be
created unless needed, so I prefer testing on this property.

     if (!_closed) {
       throw new SpannableAssertionFailure(
           NO_LOCATION_SPANNABLE, "The world builder has not yet been closed.");
     }
     return _closedWorldCache;
   }
 
   /// All directly instantiated classes, that is, classes with a generative
   /// constructor that has been called directly and not only through a
   /// super-call.
@@ skipping 584 matching lines @@
   ClosedWorld get closedWorldCache {
     assert(isClosed);
     return _closedWorldCache;
   }
 }
 
 /// World builder specific to codegen.
 ///
 /// This adds additional access to liveness of selectors and elements.
 abstract class CodegenWorldBuilder implements WorldBuilder {
+  /// Opens this world builder using [closedWorld] as the known superset of
+  /// possible runtime entities.
+  void open(ClosedWorld closedWorld);
+
   void forEachInvokedName(
       f(String name, Map<Selector, SelectorConstraints> selectors));
 
   void forEachInvokedGetter(
       f(String name, Map<Selector, SelectorConstraints> selectors));
 
   void forEachInvokedSetter(
       f(String name, Map<Selector, SelectorConstraints> selectors));
 
   /// Returns `true` if [member] is invoked as a setter.
@@ skipping 11 matching lines @@
   Iterable<FunctionElement> get methodsNeedingSuperGetter;
 
   /// The set of all referenced static fields.
   ///
   /// Invariant: Elements are declaration elements.
   Iterable<FieldElement> get allReferencedStaticFields;
 }
 
 class CodegenWorldBuilderImpl implements CodegenWorldBuilder {
   final Backend _backend;
+  ClosedWorld __world;

[Siggi Cherem (dart-lang), 2017/01/03 17:46:08]

I guess this is really really private ;-)

 
   /// The set of all directly instantiated classes, that is, classes with a
   /// generative constructor that has been called directly and not only through
   /// a super-call.
   ///
   /// Invariant: Elements are declaration elements.
   // TODO(johnniwinther): [_directlyInstantiatedClasses] and
   // [_instantiatedTypes] sets should be merged.
   final Set<ClassElement> _directlyInstantiatedClasses =
       new Set<ClassElement>();
@@ skipping 48 matching lines @@
   /// closurized.
   final Map<String, Set<_MemberUsage>> _instanceFunctionsByName =
       <String, Set<_MemberUsage>>{};
 
   final Set<DartType> isChecks = new Set<DartType>();
 
   final SelectorConstraintsStrategy selectorConstraintsStrategy;
 
   CodegenWorldBuilderImpl(this._backend, this.selectorConstraintsStrategy);
 
-  // TODO(johnniwinther): Remove this hack:
-  ClosedWorld get _world =>
-      _backend.compiler.resolverWorld.closedWorldForTesting;
+  void open(ClosedWorld closedWorld) {
+    assert(invariant(NO_LOCATION_SPANNABLE, __world == null,
+        message: "CodegenWorldBuilder has already been opened."));
+    __world = closedWorld;
+  }
+
+  ClosedWorld get _world {
+    assert(invariant(NO_LOCATION_SPANNABLE, __world != null,
+        message: "CodegenWorldBuilder has not been opened."));
+    return __world;
+  }
 
   Iterable<ClassElement> get processedClasses => _processedClasses.keys
       .where((cls) => _processedClasses[cls].isInstantiated);
 
   /// All directly instantiated classes, that is, classes with a generative
   /// constructor that has been called directly and not only through a
   /// super-call.
   // TODO(johnniwinther): Improve semantic precision.
   Iterable<ClassElement> get directlyInstantiatedClasses {
     return _directlyInstantiatedClasses;
@@ skipping 721 matching lines @@
   @override
   EnumSet<MemberUse> get _originalUse => MemberUses.ALL_STATIC;
 }
 
 void removeFromSet(Map<String, Set<_MemberUsage>> map, Element element) {
   Set<_MemberUsage> set = map[element.name];
   if (set == null) return;
   set.removeAll(
       set.where((_MemberUsage usage) => usage.entity == element).toList());
 }