Move remaining functionality from ClassWorld to ClosedWorld

pkg/compiler/lib/src/world.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 dart2js.world;
 
 import 'closure.dart' show SynthesizedCallMethodElementX;
 import 'common/backend_api.dart' show Backend;
 import 'common.dart';
 import 'compiler.dart' show Compiler;
 import 'core_types.dart' show CoreClasses;
 import 'dart_types.dart';
 import 'elements/elements.dart'
     show
         ClassElement,
         Element,
         FunctionElement,
         MixinApplicationElement,
         TypedefElement,
         VariableElement;
 import 'js_backend/backend.dart' show JavaScriptBackend;
 import 'ordered_typeset.dart';
 import 'types/masks.dart' show CommonMasks, FlatTypeMask, TypeMask;
 import 'universe/class_set.dart';
 import 'universe/function_set.dart' show FunctionSet;
 import 'universe/selector.dart' show Selector;
 import 'universe/side_effects.dart' show SideEffects;
 import 'util/util.dart' show Link;
 
-/// The [ClassWorld] represents the information known about a program when
+/// Common superinterface for [OpenWorld] and [ClosedWorld].
+abstract class World {}
+
+/// The [ClosedWorld] represents the information known about a program when
 /// compiling with closed-world semantics.
 ///
 /// Given the entrypoint of an application, we can track what's reachable from
 /// it, what functions are called, what classes are allocated, which native
 /// JavaScript types are touched, what language features are used, and so on.
 /// This precise knowledge about what's live in the program is later used in
 /// optimizations and other compiler decisions during code generation.
-abstract class ClassWorld {
+abstract class ClosedWorld implements World {
   // TODO(johnniwinther): Refine this into a `BackendClasses` interface.
   Backend get backend;
 
   CoreClasses get coreClasses;
 
-  /// Returns `true` if the class world is closed.
-  bool get isClosed;
-
-  /// Returns `true` if closed-world assumptions can be made, that is,
-  /// incremental compilation isn't enabled.
-  bool get hasClosedWorldAssumption;
-
-  /// Returns a string representation of the closed world.
-  ///
-  /// If [cls] is provided, the dump will contain only classes related to [cls].
-  String dump([ClassElement cls]);
-
-  /// Returns [ClassHierarchyNode] for [cls] used to model the class hierarchies
-  /// of known classes.
-  ///
-  /// This method is only provided for testing. For queries on classes, use the
-  /// methods defined in [ClassWorld].
-  ClassHierarchyNode getClassHierarchyNode(ClassElement cls);
-
-  /// Returns [ClassSet] for [cls] used to model the extends and implements
-  /// relations of known classes.
-  ///
-  /// This method is only provided for testing. For queries on classes, use the
-  /// methods defined in [ClassWorld].
-  ClassSet getClassSet(ClassElement cls);
-
-  // TODO(johnniwinther): Find a better strategy for caching these.
-  @deprecated
-  List<Map<ClassElement, TypeMask>> get canonicalizedTypeMasks;
-}
-
-/// The [ClosedWorld] represents the information known about a program when
-/// compiling with closed-world semantics.
-///
-/// This expands [ClassWorld] with information about live functions,
-/// side effects, and selectors with known single targets.
-abstract class ClosedWorld extends ClassWorld {
   /// Returns `true` if [cls] is either directly or indirectly instantiated.
   bool isInstantiated(ClassElement cls);
 
   /// Returns `true` if [cls] is directly instantiated.
   bool isDirectlyInstantiated(ClassElement cls);
 
   /// Returns `true` if [cls] is indirectly instantiated, that is through a
   /// subclass.
   bool isIndirectlyInstantiated(ClassElement cls);
 
@@ skipping 91 matching lines @@
   /// Returns `true` if [cls] or any superclass mixes in [mixin].
   bool isSubclassOfMixinUseOf(ClassElement cls, ClassElement mixin);
 
   /// Returns `true` if every subtype of [x] is a subclass of [y] or a subclass
   /// of a mixin application of [y].
   bool everySubtypeIsSubclassOfOrMixinUseOf(ClassElement x, ClassElement y);
 
   /// Returns `true` if any subclass of [superclass] implements [type].
   bool hasAnySubclassThatImplements(ClassElement superclass, ClassElement type);
 
+  /// Returns [ClassHierarchyNode] for [cls] used to model the class hierarchies
+  /// of known classes.
+  ///
+  /// This method is only provided for testing. For queries on classes, use the
+  /// methods defined in [ClosedWorld].
+  ClassHierarchyNode getClassHierarchyNode(ClassElement cls);
+
+  /// Returns [ClassSet] for [cls] used to model the extends and implements
+  /// relations of known classes.
+  ///
+  /// This method is only provided for testing. For queries on classes, use the
+  /// methods defined in [ClosedWorld].
+  ClassSet getClassSet(ClassElement cls);
+
+  // TODO(johnniwinther): Find a better strategy for caching these.
+  @deprecated
+  List<Map<ClassElement, TypeMask>> get canonicalizedTypeMasks;
+
   /// Returns the [FunctionSet] containing all live functions in the closed
   /// world.
   FunctionSet get allFunctions;
 
   /// Returns `true` if the field [element] is known to be effectively final.
   bool fieldNeverChanges(Element element);
 
   /// Extends the receiver type [mask] for calling [selector] to take live
   /// `noSuchMethod` handlers into account.
   TypeMask extendMaskIfReachesAll(Selector selector, TypeMask mask);
@@ skipping 21 matching lines @@
   bool getCannotThrow(Element element);
 
   /// Returns `true` if [element] is called in a loop.
   // TODO(johnniwinther): Is this 'potentially called' or 'known to be called'?
   bool isCalledInLoop(Element element);
 
   /// Returns `true` if [element] might be passed to `Function.apply`.
   // TODO(johnniwinther): Is this 'passed invocation target` or
   // `passed as argument`?
   bool getMightBePassedToApply(Element element);
+
+  /// Returns a string representation of the closed world.
+  ///
+  /// If [cls] is provided, the dump will contain only classes related to [cls].
+  String dump([ClassElement cls]);
 }
 
 /// Interface for computing side effects and uses of elements. This is used
 /// during type inference to compute the [ClosedWorld] for code generation.
 abstract class ClosedWorldRefiner {
   /// Registers the side [effects] of executing [element].
   void registerSideEffects(Element element, SideEffects effects);
 
   /// Registers the executing of [element] as without side effects.
   void registerSideEffectsFree(Element element);
@@ skipping 15 matching lines @@
   void addFunctionCalledInLoop(Element element);
 
   /// Registers that [element] is guaranteed not to throw an exception.
   void registerCannotThrow(Element element);
 
   /// Adds the closure class [cls] to the inference world. The class is
   /// considered directly instantiated.
   void registerClosureClass(ClassElement cls);
 }
 
-abstract class OpenWorld implements ClassWorld {
+abstract class OpenWorld implements World {
   /// Called to add [cls] to the set of known classes.
   ///
   /// This ensures that class hierarchy queries can be performed on [cls] and
   /// classes that extend or implement it.
   void registerClass(ClassElement cls);
 
   void registerUsedElement(Element element);
   void registerTypedef(TypedefElement typedef);
 
   ClosedWorld closeWorld();
@@ skipping 463 matching lines @@
   void registerTypedef(TypedefElement typdef) {
     _allTypedefs.add(typdef);
   }
 
   Iterable<TypedefElement> get allTypedefs => _allTypedefs;
 
   /// Returns [ClassHierarchyNode] for [cls] used to model the class hierarchies
   /// of known classes.
   ///
   /// This method is only provided for testing. For queries on classes, use the
-  /// methods defined in [ClassWorld].
+  /// methods defined in [ClosedWorld].
   ClassHierarchyNode getClassHierarchyNode(ClassElement cls) {
     return _classHierarchyNodes[cls.declaration];
   }
 
   ClassHierarchyNode _ensureClassHierarchyNode(ClassElement cls) {
     cls = cls.declaration;
     return _classHierarchyNodes.putIfAbsent(cls, () {
       ClassHierarchyNode parentNode;
       if (cls.superclass != null) {
         parentNode = _ensureClassHierarchyNode(cls.superclass);
       }
       return new ClassHierarchyNode(parentNode, cls);
     });
   }
 
   /// Returns [ClassSet] for [cls] used to model the extends and implements
   /// relations of known classes.
   ///
   /// This method is only provided for testing. For queries on classes, use the
-  /// methods defined in [ClassWorld].
+  /// methods defined in [ClosedWorld].
   ClassSet getClassSet(ClassElement cls) {
     return _classSets[cls.declaration];
   }
 
   ClassSet _ensureClassSet(ClassElement cls) {
     cls = cls.declaration;
     return _classSets.putIfAbsent(cls, () {
       ClassHierarchyNode node = _ensureClassHierarchyNode(cls);
       ClassSet classSet = new ClassSet(node);
 
@@ skipping 234 matching lines @@
     if (element is SynthesizedCallMethodElementX) {
       return getMightBePassedToApply(element.expression);
     }
     return functionsThatMightBePassedToApply.contains(element);
   }
 
   @override
   bool getCurrentlyKnownMightBePassedToApply(Element element) {
     return getMightBePassedToApply(element);
   }
-
-  bool get hasClosedWorldAssumption => !_compiler.options.hasIncrementalSupport;
 }