Make ClosedWorld a `forTesting` property of ResolutionWorldBuilder.

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 154 matching lines @@
   /// directly and abstractly instantiated classes but also classes whose type
   /// arguments are used in live factory constructors.
   void forEachInstantiatedClass(f(ClassElement cls, InstantiationInfo info));
 
   /// Returns `true` if [member] is invoked as a setter.
   bool hasInvokedSetter(Element member);
 
   /// 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
 /// `ResolutionWorldBuilder.registerTypeInstantiation`.
 class Instance {
   final InterfaceType type;
   final Instantiation kind;
   final bool isRedirection;
 
   Instance(this.type, this.kind, {this.isRedirection: false});
@@ skipping 233 matching lines @@
   final SelectorConstraintsStrategy selectorConstraintsStrategy;
 
   bool hasRuntimeTypeSupport = false;
   bool hasIsolateSupport = false;
   bool hasFunctionApplySupport = false;
 
   /// Used for testing the new more precise computation of instantiated types
   /// and classes.
   bool useInstantiationMap = false;
 
-  OpenWorld _openWorld;
+  WorldImpl _openWorld;
 
   final Backend _backend;
   final Resolution _resolution;
 
   ResolutionWorldBuilderImpl(Backend backend, Resolution resolution,
       CacheStrategy cacheStrategy, this.selectorConstraintsStrategy)
       : this._backend = backend,
         this._resolution = resolution {
     _openWorld = new WorldImpl(this, backend, resolution.coreClasses,
         resolution.coreTypes, cacheStrategy);
   }
 
   Iterable<ClassElement> get processedClasses => _processedClasses.keys
       .where((cls) => _processedClasses[cls].isInstantiated);
 
   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.
   // TODO(johnniwinther): Improve semantic precision.
   Iterable<ClassElement> get directlyInstantiatedClasses {
     Set<ClassElement> classes = new Set<ClassElement>();
     getInstantiationMap().forEach((ClassElement cls, InstantiationInfo info) {
       if (info.hasInstantiation) {
         classes.add(cls);
       }
@@ skipping 1072 matching lines @@
     if (hasClosurization) {
       return MemberUses.NONE;
     }
     hasNormalUse = hasClosurization = true;
     return _pendingUse.removeAll(MemberUses.ALL_STATIC);
   }
 
   @override
   EnumSet<MemberUse> get _originalUse => MemberUses.ALL_STATIC;
 }