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

pkg/compiler/lib/src/universe/function_set.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.function_set;
 
 import '../common/names.dart' show Identifiers, Selectors;
 import '../compiler.dart' show Compiler;
 import '../elements/elements.dart';
 import '../types/types.dart';
 import '../util/util.dart' show Hashing, Setlet;
 import '../world.dart' show ClassWorld;
 import 'selector.dart' show Selector;
 import 'universe.dart' show ReceiverConstraint;
 
 // TODO(kasperl): This actually holds getters and setters just fine
 // too and stricly they aren't functions. Maybe this needs a better
 // name -- something like ElementSet seems a bit too generic.
 class FunctionSet {
   final Compiler compiler;
   final Map<String, FunctionSetNode> nodes = new Map<String, FunctionSetNode>();
   FunctionSet(this.compiler);
 
-  ClassWorld get classWorld => compiler.world;
+  ClassWorld get classWorld => compiler.closedWorld;
 
   FunctionSetNode newNode(String name) => new FunctionSetNode(name);
 
   void add(Element element) {
     assert(element.isInstanceMember);
     assert(!element.isAbstract);
     String name = element.name;
     FunctionSetNode node = nodes.putIfAbsent(name, () => newNode(name));
     node.add(element);
   }
@@ skipping 29 matching lines @@
   /// set of classes that actually implement the selected member or implement
   /// the handling 'noSuchMethod' where the selected member is unimplemented.
   TypeMask receiverType(Selector selector, ReceiverConstraint constraint) {
     return query(selector, constraint).computeMask(classWorld);
   }
 
   SelectorMask _createSelectorMask(
       Selector selector, ReceiverConstraint constraint, ClassWorld classWorld) {
     return constraint != null
         ? new SelectorMask(selector, constraint)
-        : new SelectorMask(selector,
-            new TypeMask.subclass(classWorld.objectClass, classWorld));
+        : new SelectorMask(
+            selector,
+            new TypeMask.subclass(
+                classWorld.coreClasses.objectClass, classWorld));
   }
 
   /// Returns the set of functions that can be the target of a call to
   /// [selector] on a receiver constrained by [constraint] including
   /// 'noSuchMethod' methods where applicable.
   FunctionSetQuery query(Selector selector, ReceiverConstraint constraint) {
     String name = selector.name;
     SelectorMask selectorMask =
         _createSelectorMask(selector, constraint, classWorld);
     SelectorMask noSuchMethodMask =
@@ skipping 183 matching lines @@
 class FullFunctionSetQuery implements FunctionSetQuery {
   @override
   final Iterable<Element> functions;
 
   TypeMask _mask;
 
   FullFunctionSetQuery(this.functions);
 
   @override
   TypeMask computeMask(ClassWorld classWorld) {
-    assert(classWorld.hasAnyStrictSubclass(classWorld.objectClass));
+    assert(classWorld.hasAnyStrictSubclass(classWorld.coreClasses.objectClass));
     if (_mask != null) return _mask;
     return _mask = new TypeMask.unionOf(
         functions.expand((element) {
           ClassElement cls = element.enclosingClass;
           return [cls]..addAll(classWorld.mixinUsesOf(cls));
         }).map((cls) {
           if (classWorld.backend.isNullImplementation(cls)) {
             return const TypeMask.empty();
           } else if (classWorld.isInstantiated(cls.declaration)) {
             return new TypeMask.nonNullSubclass(cls.declaration, classWorld);
           } else {
             // TODO(johnniwinther): Avoid the need for this case.
             return const TypeMask.empty();
           }
         }),
         classWorld);
   }
 }