Introduce OpenWorld.

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, World;
+import '../world.dart' show ClassWorld, 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() {}
@@ skipping 95 matching lines @@
   /// 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, World world);
+  bool hasInvokedSetter(Element member, ClassWorld 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 150 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, World world) {
+      Element member, ClassWorld world) {
     if (selectors == null) return false;
     for (Selector selector in selectors.keys) {
-      if (selector.appliesUnnamed(member, world)) {
+      if (selector.appliesUnnamed(member, world.backend)) {
         SelectorConstraints masks = selectors[selector];
         if (masks.applies(member, selector, world)) {
           return true;
         }
       }
     }
     return false;
   }
 
-  bool hasInvocation(Element member, World world) {
+  bool hasInvocation(Element member, OpenWorld world) {
     return _hasMatchingSelector(_invokedNames[member.name], member, world);
   }
 
-  bool hasInvokedGetter(Element member, World world) {
+  bool hasInvokedGetter(Element member, OpenWorld world) {
     return _hasMatchingSelector(_invokedGetters[member.name], member, world) ||
         member.isFunction && methodsNeedingSuperGetter.contains(member);
   }
 
-  bool hasInvokedSetter(Element member, World world) {
+  bool hasInvokedSetter(Element member, OpenWorld world) {
     return _hasMatchingSelector(_invokedSetters[member.name], member, world);
   }
 
   bool registerDynamicUse(DynamicUse dynamicUse) {
     switch (dynamicUse.kind) {
       case DynamicUseKind.INVOKE:
         return _registerNewSelector(dynamicUse, _invokedNames);
       case DynamicUseKind.GET:
         return _registerNewSelector(dynamicUse, _invokedGetters);
       case DynamicUseKind.SET:
@@ skipping 75 matching lines @@
 abstract class CodegenUniverse implements Universe {
   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));
 
-  bool hasInvokedGetter(Element member, World world);
+  bool hasInvokedGetter(Element member, ClosedWorld world);
 
   Map<Selector, SelectorConstraints> invocationsByName(String name);
 
   Map<Selector, SelectorConstraints> getterInvocationsByName(String name);
 
   Map<Selector, SelectorConstraints> setterInvocationsByName(String name);
 
   Iterable<FunctionElement> get staticFunctionsNeedingGetter;
   Iterable<FunctionElement> get methodsNeedingSuperGetter;
 
@@ skipping 98 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, World world) {
+      Element member, ClosedWorld world) {
     if (selectors == null) return false;
     for (Selector selector in selectors.keys) {
-      if (selector.appliesUnnamed(member, world)) {
+      if (selector.appliesUnnamed(member, world.backend)) {
         SelectorConstraints masks = selectors[selector];
         if (masks.applies(member, selector, world)) {
           return true;
         }
       }
     }
     return false;
   }
 
-  bool hasInvocation(Element member, World world) {
+  bool hasInvocation(Element member, ClosedWorld world) {
     return _hasMatchingSelector(_invokedNames[member.name], member, world);
   }
 
-  bool hasInvokedGetter(Element member, World world) {
+  bool hasInvokedGetter(Element member, ClosedWorld world) {
     return _hasMatchingSelector(_invokedGetters[member.name], member, world) ||
         member.isFunction && methodsNeedingSuperGetter.contains(member);
   }
 
-  bool hasInvokedSetter(Element member, World world) {
+  bool hasInvokedSetter(Element member, ClosedWorld world) {
     return _hasMatchingSelector(_invokedSetters[member.name], member, world);
   }
 
   bool registerDynamicUse(DynamicUse dynamicUse) {
     switch (dynamicUse.kind) {
       case DynamicUseKind.INVOKE:
         return _registerNewSelector(dynamicUse, _invokedNames);
       case DynamicUseKind.GET:
         return _registerNewSelector(dynamicUse, _invokedGetters);
       case DynamicUseKind.SET:
@@ skipping 81 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);
     }
   }
 }