Extract ClosedWorldImpl from WorldImpl.

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 91 matching lines @@
 }
 
 /// Strategy for computing the constraints on potential receivers of dynamic
 /// call sites.
 abstract class SelectorConstraintsStrategy {
   /// Create a [UniverseSelectorConstraints] to represent the global receiver
   /// constraints for dynamic call sites with [selector].
   UniverseSelectorConstraints createSelectorConstraints(Selector selector);
 }
 
+class OpenWorldStrategy implements SelectorConstraintsStrategy {
+  const OpenWorldStrategy();
+
+  OpenWorldConstraints createSelectorConstraints(Selector selector) {
+    return new OpenWorldConstraints();
+  }
+}
+
+class OpenWorldConstraints extends UniverseSelectorConstraints {
+  bool isAll = false;
+
+  @override
+  bool applies(Element element, Selector selector, World world) => isAll;
+
+  @override
+  bool needsNoSuchMethodHandling(Selector selector, World world) => isAll;
+
+  @override
+  bool addReceiverConstraint(ReceiverConstraint constraint) {
+    if (isAll) return false;
+    isAll = true;
+    return true;
+  }
+
+  String toString() {
+    if (isAll) {
+      return '<all>';
+    } else {
+      return '<none>';
+    }
+  }
+}
+
 /// The [WorldBuilder] is an auxiliary class used in the process of computing
 /// the [ClosedWorld].
 // TODO(johnniwinther): Move common implementation to a [WorldBuilderBase] when
 // universes and worlds have been unified.
 abstract class WorldBuilder {
   /// 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;
@@ skipping 324 matching lines @@
   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;
+    return _openWorld.closedWorldCache;
   }
 
   /// 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) {
@@ skipping 1074 matching lines @@
     if (hasClosurization) {
       return MemberUses.NONE;
     }
     hasNormalUse = hasClosurization = true;
     return _pendingUse.removeAll(MemberUses.ALL_STATIC);
   }
 
   @override
   EnumSet<MemberUse> get _originalUse => MemberUses.ALL_STATIC;
 }