Move remaining functionality from ClassWorld to ClosedWorld

pkg/compiler/lib/src/universe/universe.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 '../common.dart';
 import '../compiler.dart' show Compiler;
 import '../dart_types.dart';
 import '../elements/elements.dart';
 import '../util/util.dart';
-import '../world.dart' show ClassWorld, ClosedWorld, OpenWorld;
+import '../world.dart' show World, ClosedWorld, OpenWorld;
 import 'selector.dart' show Selector;
 import 'use.dart' show DynamicUse, DynamicUseKind, StaticUse, StaticUseKind;
 
 /// The known constraint on receiver for a dynamic call site.
 ///
 /// This can for instance be used to constrain this dynamic call to `foo` to
 /// 'receivers of the exact instance `Bar`':
 ///
 ///     class Bar {
 ///        void foo() {}
 ///     }
 ///     main() => new Bar().foo();
 ///
 abstract class ReceiverConstraint {
   /// Returns whether [element] is a potential target when being
   /// invoked on a receiver with this constraint. [selector] is used to ensure
   /// library privacy is taken into account.
-  bool canHit(Element element, Selector selector, ClassWorld classWorld);
+  bool canHit(Element element, Selector selector, World world);
 
   /// Returns whether this [TypeMask] applied to [selector] can hit a
   /// [noSuchMethod].
-  bool needsNoSuchMethodHandling(Selector selector, ClassWorld classWorld);
+  bool needsNoSuchMethodHandling(Selector selector, World world);
 }
 
 /// The combined constraints on receivers all the dynamic call sites of the same
 /// selector.
 ///
 /// For instance for these calls
 ///
 ///     class A {
 ///        foo(a, b) {}
 ///     }
@@ skipping 17 matching lines @@
   ///     class A {
   ///        foo(a, b) {}
   ///     }
   ///     class B {
   ///        foo(a, b) {}
   ///     }
   ///     new A().foo(a, b);
   ///
   /// Ideally the selector constraints for calls `foo` with two positional
   /// arguments apply to `A.foo` but `B.foo`.
-  bool applies(Element element, Selector selector, ClassWorld world);
+  bool applies(Element element, Selector selector, World world);
 
   /// Returns `true` if at least one of the receivers matching these constraints
   /// in the closed [world] have no implementation matching [selector].
   ///
   /// For instance for this code snippet
   ///
   ///     class A {}
   ///     class B { foo() {} }
   ///     m(b) => (b ? new A() : new B()).foo();
   ///
   /// the potential receiver `new A()` has no implementation of `foo` and thus
   /// needs to handle the call through its `noSuchMethod` handler.
-  bool needsNoSuchMethodHandling(Selector selector, ClassWorld world);
+  bool needsNoSuchMethodHandling(Selector selector, World world);
 }
 
 /// A mutable [SelectorConstraints] used in [Universe].
 abstract class UniverseSelectorConstraints extends SelectorConstraints {
   /// Adds [constraint] to these selector constraints. Return `true` if the set
   /// of potential receivers expanded due to the new constraint.
   bool addReceiverConstraint(ReceiverConstraint constraint);
 }
 
 /// 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);
 }
 
 /// The [Universe] is an auxiliary class used in the process of computing the
-/// [ClassWorld]. The concepts here and in [ClassWorld] are very similar -- in
+/// [ClosedWorld]. The concepts here and in [ClosedWorld] are very similar -- in
 /// the same way that the "universe expands" you can think of this as a mutable
 /// world that is expanding as we visit and discover parts of the program.
 // TODO(sigmund): rename to "growing/expanding/mutable world"?
 // TODO(johnniwinther): Move common implementation to a [UniverseBase] when
 // universes and worlds have been unified.
 abstract class Universe {
   /// 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;
 
   /// All types that are checked either through is, as or checked mode checks.
   Iterable<DartType> get isChecks;
 
   /// Registers that [type] is checked in this universe. The unaliased type is
   /// returned.
   DartType registerIsCheck(DartType type, Compiler compiler);
 
   /// All directly instantiated types, that is, the types of the directly
   /// instantiated classes.
   // TODO(johnniwinther): Improve semantic precision.
   Iterable<DartType> get instantiatedTypes;
 
   /// Returns `true` if [member] is invoked as a setter.
-  bool hasInvokedSetter(Element member, ClassWorld world);
+  bool hasInvokedSetter(Element member, World world);
 }
 
 abstract class ResolutionUniverse implements Universe {
   /// Set of (live) local functions (closures) whose signatures reference type
   /// variables.
   ///
   /// A live function is one whose enclosing member function has been enqueued.
   Set<Element> get closuresWithFreeTypeVariables;
 
   /// Set of (live) `call` methods whose signatures reference type variables.
@@ skipping 149 matching lines @@
       onImplemented(cls);
       cls.allSupertypes.forEach((InterfaceType supertype) {
         if (_implementedClasses.add(supertype.element)) {
           onImplemented(supertype.element);
         }
       });
     }
   }
 
   bool _hasMatchingSelector(Map<Selector, SelectorConstraints> selectors,
-      Element member, ClassWorld world) {
+      Element member, OpenWorld world) {
     if (selectors == null) return false;
     for (Selector selector in selectors.keys) {
-      if (selector.appliesUnnamed(member, world.backend)) {
+      if (selector.appliesUnnamed(member)) {
         SelectorConstraints masks = selectors[selector];
         if (masks.applies(member, selector, world)) {
           return true;
         }
       }
     }
     return false;
   }
 
   bool hasInvocation(Element member, OpenWorld world) {
@@ skipping 219 matching lines @@
           onImplemented(supertype.element);
         }
       });
     }
   }
 
   bool _hasMatchingSelector(Map<Selector, SelectorConstraints> selectors,
       Element member, ClosedWorld world) {
     if (selectors == null) return false;
     for (Selector selector in selectors.keys) {
-      if (selector.appliesUnnamed(member, world.backend)) {
+      if (selector.appliesUnnamed(member)) {
         SelectorConstraints masks = selectors[selector];
         if (masks.applies(member, selector, world)) {
           return true;
         }
       }
     }
     return false;
   }
 
   bool hasInvocation(Element member, ClosedWorld world) {
@@ skipping 100 matching lines @@
 
   void forgetElement(Element element, Compiler compiler) {
     _directlyInstantiatedClasses.remove(element);
     if (element is ClassElement) {
       assert(invariant(element, element.thisType.isRaw,
           message: 'Generic classes not supported (${element.thisType}).'));
       _instantiatedTypes..remove(element.rawType)..remove(element.thisType);
     }
   }
 }