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

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 'ordered_typeset.dart';
-import 'types/masks.dart' show TypeMask, FlatTypeMask;
+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
 /// 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 {
   // TODO(johnniwinther): Refine this into a `BackendClasses` interface.
   Backend get backend;
 
-  // TODO(johnniwinther): Remove the need for this getter.
-  @deprecated
-  Compiler get compiler;
+  CommonMasks get commonMasks;

[Siggi Cherem (dart-lang), 2016/09/06 20:23:08]

I really wonder whether we want to also expose these here or if we should pass
them explicitly where they are used.

It does feels like a worldly worthy thing, but I don't want "world" to become
the next "compiler" :)

[Johnni Winther, 2016/09/19 13:03:49]

Removed. It was only need in an assertion where a workaround could be applied.

 
-  /// The [ClassElement] for the [Object] class defined in 'dart:core'.
-  ClassElement get objectClass;
-
-  /// The [ClassElement] for the [Function] class defined in 'dart:core'.
-  ClassElement get functionClass;
-
-  /// The [ClassElement] for the [bool] class defined in 'dart:core'.
-  ClassElement get boolClass;
-
-  /// The [ClassElement] for the [num] class defined in 'dart:core'.
-  ClassElement get numClass;
-
-  /// The [ClassElement] for the [int] class defined in 'dart:core'.
-  ClassElement get intClass;
-
-  /// The [ClassElement] for the [double] class defined in 'dart:core'.
-  ClassElement get doubleClass;
-
-  /// The [ClassElement] for the [String] class defined in 'dart:core'.
-  ClassElement get stringClass;
+  CoreClasses get coreClasses;
 
   /// 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 103 matching lines @@
   bool hasAnySubclassThatImplements(ClassElement superclass, ClassElement type);
 
   /// 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);
 }
 
-class World implements ClassWorld {
-  ClassElement get objectClass => coreClasses.objectClass;
-  ClassElement get functionClass => coreClasses.functionClass;
-  ClassElement get boolClass => coreClasses.boolClass;
-  ClassElement get numClass => coreClasses.numClass;
-  ClassElement get intClass => coreClasses.intClass;
-  ClassElement get doubleClass => coreClasses.doubleClass;
-  ClassElement get stringClass => coreClasses.stringClass;
-  ClassElement get nullClass => coreClasses.nullClass;
+abstract class ClosedWorld extends ClassWorld {

[Siggi Cherem (dart-lang), 2016/09/06 20:23:09]

+ dartdoc

[Johnni Winther, 2016/09/19 13:03:49]

Done.

+  /// 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);
+
+  /// Returns all resolved typedefs.
+  Iterable<TypedefElement> get allTypedefs;
+
+  /// Returns the single [Element] that matches a call to [selector] on a
+  /// receiver of type [mask]. If multiple targets exists, `null` is returned.
+  Element locateSingleElement(Selector selector, TypeMask mask);
+
+  /// Returns the single field that matches a call to [selector] on a
+  /// receiver of type [mask]. If multiple targets exists or the single target
+  /// is not a field, `null` is returned.
+  VariableElement locateSingleField(Selector selector, TypeMask mask);
+
+  /// Returns the side effects of executing [element].
+  SideEffects getSideEffectsOfElement(Element element);
+
+  /// Returns the side effects of calling [selector] on a receiver of type
+  /// [mask].
+  SideEffects getSideEffectsOfSelector(Selector selector, TypeMask mask);
+
+  /// Returns `true` if [element] is guaranteed not to throw an exception.
+  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);
+}
+
+abstract class InferenceWorld {

[Siggi Cherem (dart-lang), 2016/09/06 20:23:08]

Interesting... this is good to see, because it highlights to me how the
information is flowing out of the global type-inference into the closed world. 

I'm not sure whether this belong here, though. Some methods below feel like a
way to provide input to the global type-inference task, so we should split that
out. Some methods are reporting the final result of type-inference, so maybe we
should expose first the result of type-inference and separately compute the
world that has those results?

This might become more clear once we resolve the longer redesign question I
raised earlier and as we make progress refactoring the global type-inference
task.

[Johnni Winther, 2016/09/19 13:03:49]

Renamed the class to [ClosedWorldRefiner] and add the `CurrentlyKnown` infix to
the getter to show that these current and not final results of the computation.

+  /// 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);
+
+  /// Returns the currently known side effects of executing [element].
+  SideEffects getSideEffectsOfElement(Element element);
+
+  /// Registers that [element] might be passed to `Function.apply`.
+  // TODO(johnniwinther): Is this 'passed invocation target` or
+  // `passed as argument`?
+  void registerMightBePassedToApply(Element element);
+
+  /// Returns `true` if [element] might be passed to `Function.apply` given the
+  /// currently inferred information.
+  bool getMightBePassedToApply(Element element);
+
+  /// Registers that [element] is called in a loop.
+  // TODO(johnniwinther): Is this 'potentially called' or 'known to be called'?
+  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);
+}
+
+class World implements ClosedWorld, InferenceWorld {
   /// Cache of [FlatTypeMask]s grouped by the 8 possible values of the
   /// `FlatTypeMask.flags` property.
   List<Map<ClassElement, TypeMask>> canonicalizedTypeMasks =
       new List<Map<ClassElement, TypeMask>>.filled(8, null);
 
   bool checkInvariants(ClassElement cls, {bool mustBeInstantiated: true}) {
     return invariant(cls, cls.isDeclaration,
                 message: '$cls must be the declaration.') &&
             invariant(cls, cls.isResolved,
                 message:
                     '$cls must be resolved.') /* &&
       // TODO(johnniwinther): Reinsert this or similar invariant.
       (!mustBeInstantiated ||
        invariant(cls, isInstantiated(cls),
                  message: '$cls is not instantiated.'))*/
         ;
   }
 
   /// Returns `true` if [x] is a subtype of [y], that is, if [x] implements an
   /// instance of [y].
   bool isSubtypeOf(ClassElement x, ClassElement y) {
     assert(checkInvariants(x));
     assert(checkInvariants(y, mustBeInstantiated: false));
 
-    if (y == objectClass) return true;
-    if (x == objectClass) return false;
+    if (y == coreClasses.objectClass) return true;
+    if (x == coreClasses.objectClass) return false;
     if (x.asInstanceOf(y) != null) return true;
-    if (y != functionClass) return false;
+    if (y != coreClasses.functionClass) return false;
     return x.callType != null;
   }
 
   /// Return `true` if [x] is a (non-strict) subclass of [y].
   bool isSubclassOf(ClassElement x, ClassElement y) {
     assert(checkInvariants(x));
     assert(checkInvariants(y));
 
-    if (y == objectClass) return true;
-    if (x == objectClass) return false;
+    if (y == coreClasses.objectClass) return true;
+    if (x == coreClasses.objectClass) return false;
     while (x != null && x.hierarchyDepth >= y.hierarchyDepth) {
       if (x == y) return true;
       x = x.superclass;
     }
     return false;
   }
 
   @override
   bool isInstantiated(ClassElement cls) {
     ClassHierarchyNode node = _classHierarchyNodes[cls.declaration];
     return node != null && node.isInstantiated;
   }
 
   @override
   bool isDirectlyInstantiated(ClassElement cls) {
     ClassHierarchyNode node = _classHierarchyNodes[cls.declaration];
     return node != null && node.isDirectlyInstantiated;
   }
 
   @override
   bool isIndirectlyInstantiated(ClassElement cls) {
     ClassHierarchyNode node = _classHierarchyNodes[cls.declaration];
     return node != null && node.isIndirectlyInstantiated;
   }
 
   /// Returns `true` if [cls] is implemented by an instantiated class.
   bool isImplemented(ClassElement cls) {
-    return compiler.resolverWorld.isImplemented(cls);
+    return _compiler.resolverWorld.isImplemented(cls);
   }
 
   /// Returns an iterable over the directly instantiated classes that extend
   /// [cls] possibly including [cls] itself, if it is live.
   Iterable<ClassElement> subclassesOf(ClassElement cls) {
     ClassHierarchyNode hierarchy = _classHierarchyNodes[cls.declaration];
     if (hierarchy == null) return const <ClassElement>[];
     return hierarchy.subclassesByMask(ClassHierarchyNode.DIRECTLY_INSTANTIATED);
   }
 
@@ skipping 111 matching lines @@
   /// Returns `true` if any directly instantiated class other than [cls]
   /// implements [cls].
   bool hasAnyStrictSubtype(ClassElement cls) {
     return strictSubtypeCount(cls) > 0;
   }
 
   /// Returns `true` if all directly instantiated classes that implement [cls]
   /// extend it.
   bool hasOnlySubclasses(ClassElement cls) {
     // TODO(johnniwinther): move this to ClassSet?
-    if (cls == objectClass) return true;
+    if (cls == coreClasses.objectClass) return true;
     ClassSet classSet = _classSets[cls.declaration];
     if (classSet == null) {
       // Vacuously true.
       return true;
     }
     return classSet.hasOnlyInstantiatedSubclasses;
   }
 
   @override
   ClassElement getLubOfInstantiatedSubclasses(ClassElement cls) {
@@ skipping 27 matching lines @@
       OrderedTypeSet otherTypeSet = otherClass.allSupertypesAndSelf;
       otherTypeSets = otherTypeSets.prepend(otherTypeSet);
       if (otherTypeSet.maxDepth < depth) {
         depth = otherTypeSet.maxDepth;
       }
     } while (iterator.moveNext());
 
     List<ClassElement> commonSupertypes = <ClassElement>[];
     OUTER:
     for (Link<DartType> link = typeSet[depth];
-        link.head.element != objectClass;
+        link.head.element != coreClasses.objectClass;
         link = link.tail) {
       ClassElement cls = link.head.element;
       for (Link<OrderedTypeSet> link = otherTypeSets;
           !link.isEmpty;
           link = link.tail) {
         if (link.head.asInstanceOf(cls) == null) {
           continue OUTER;
         }
       }
       commonSupertypes.add(cls);
     }
-    commonSupertypes.add(objectClass);
+    commonSupertypes.add(coreClasses.objectClass);
     return commonSupertypes;
   }
 
   /// Returns an iterable over all mixin applications that mixin [cls].
   Iterable<MixinApplicationElement> allMixinUsesOf(ClassElement cls) {
     Iterable<MixinApplicationElement> uses = _mixinUses[cls];
     return uses != null ? uses : const <MixinApplicationElement>[];
   }
 
   /// Returns an iterable over the live mixin applications that mixin [cls].
@@ skipping 72 matching lines @@
   }
 
   /// Returns `true` if any subclass of [superclass] implements [type].
   bool hasAnySubclassThatImplements(
       ClassElement superclass, ClassElement type) {
     Set<ClassElement> subclasses = typesImplementedBySubclassesOf(superclass);
     if (subclasses == null) return false;
     return subclasses.contains(type);
   }
 
-  final Compiler compiler;
-  Backend get backend => compiler.backend;
+  final Compiler _compiler;
+  Backend get backend => _compiler.backend;
+  CommonMasks get commonMasks => _compiler.commonMasks;
   final FunctionSet allFunctions;
   final Set<Element> functionsCalledInLoop = new Set<Element>();
   final Map<Element, SideEffects> sideEffects = new Map<Element, SideEffects>();
 
   final Set<TypedefElement> allTypedefs = new Set<TypedefElement>();
 
   final Map<ClassElement, Set<MixinApplicationElement>> _mixinUses =
       new Map<ClassElement, Set<MixinApplicationElement>>();
   Map<ClassElement, List<MixinApplicationElement>> _liveMixinUses;
 
@@ skipping 11 matching lines @@
 
   final Set<Element> sideEffectsFreeElements = new Set<Element>();
 
   final Set<Element> elementsThatCannotThrow = new Set<Element>();
 
   final Set<Element> functionsThatMightBePassedToApply =
       new Set<FunctionElement>();
 
   final Set<Element> alreadyPopulated;
 
-  bool get isClosed => compiler.phase > Compiler.PHASE_RESOLVING;
+  bool get isClosed => _compiler.phase > Compiler.PHASE_RESOLVING;
 
   // Used by selectors.
   bool isForeign(Element element) {
-    return compiler.backend.isForeign(element);
+    return backend.isForeign(element);
   }
 
   Set<ClassElement> typesImplementedBySubclassesOf(ClassElement cls) {
     return _typesImplementedBySubclasses[cls.declaration];
   }
 
   World(Compiler compiler)
       : allFunctions = new FunctionSet(compiler),
-        this.compiler = compiler,
+        this._compiler = compiler,
         alreadyPopulated = compiler.cacheStrategy.newSet();
 
-  CoreClasses get coreClasses => compiler.coreClasses;
+  CoreClasses get coreClasses => _compiler.coreClasses;
 
-  DiagnosticReporter get reporter => compiler.reporter;
+  DiagnosticReporter get reporter => _compiler.reporter;
 
   /// 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, {bool isDirectlyInstantiated: false}) {
+  void registerClass(ClassElement cls) => _registerClass(cls);
+
+  void registerClosureClass(ClassElement cls) {
+    _registerClass(cls, isDirectlyInstantiated: true);
+  }
+
+  void _registerClass(ClassElement cls, {bool isDirectlyInstantiated: false}) {
     _ensureClassSet(cls);
     if (isDirectlyInstantiated) {
       _updateClassHierarchyNodeForClass(cls, directlyInstantiated: true);
     }
   }
 
   /// 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
@@ skipping 68 matching lines @@
     if (directlyInstantiated) {
       node.isDirectlyInstantiated = true;
     }
   }
 
   void populate() {
     /// Updates the `isDirectlyInstantiated` and `isIndirectlyInstantiated`
     /// properties of the [ClassHierarchyNode] for [cls].
 
     void addSubtypes(ClassElement cls) {
-      if (compiler.options.hasIncrementalSupport &&
+      if (_compiler.options.hasIncrementalSupport &&
           !alreadyPopulated.add(cls)) {
         return;
       }
       assert(cls.isDeclaration);
       if (!cls.isResolved) {
         reporter.internalError(cls, 'Class "${cls.name}" is not resolved.');
       }
 
       _updateClassHierarchyNodeForClass(cls, directlyInstantiated: true);
 
       // Walk through the superclasses, and record the types
       // implemented by that type on the superclasses.
       ClassElement superclass = cls.superclass;
       while (superclass != null) {
         Set<Element> typesImplementedBySubclassesOfCls =
             _typesImplementedBySubclasses.putIfAbsent(
                 superclass, () => new Set<ClassElement>());
         for (DartType current in cls.allSupertypes) {
           typesImplementedBySubclassesOfCls.add(current.element);
         }
         superclass = superclass.superclass;
       }
     }
 
     // Use the [:seenClasses:] set to include non-instantiated
     // classes: if the superclass of these classes require RTI, then
     // they also need RTI, so that a constructor passes the type
     // variables to the super constructor.
-    compiler.resolverWorld.directlyInstantiatedClasses.forEach(addSubtypes);
+    _compiler.resolverWorld.directlyInstantiatedClasses.forEach(addSubtypes);
   }
 
   @override
   String dump([ClassElement cls]) {
     StringBuffer sb = new StringBuffer();
     if (cls != null) {
       sb.write("Classes in the closed world related to $cls:\n");
     } else {
       sb.write("Instantiated classes in the closed world:\n");
     }
@@ skipping 21 matching lines @@
       allFunctions.add(element);
     }
   }
 
   VariableElement locateSingleField(Selector selector, TypeMask mask) {
     Element result = locateSingleElement(selector, mask);
     return (result != null && result.isField) ? result : null;
   }
 
   Element locateSingleElement(Selector selector, TypeMask mask) {
-    mask ??= compiler.commonMasks.dynamicType;
-    return mask.locateSingleElement(selector, compiler);
+    mask ??= commonMasks.dynamicType;
+    return mask.locateSingleElement(selector, _compiler);
   }
 
   TypeMask extendMaskIfReachesAll(Selector selector, TypeMask mask) {
     bool canReachAll = true;
     if (mask != null) {
-      canReachAll = compiler.enabledInvokeOn &&
+      canReachAll = _compiler.enabledInvokeOn &&
           mask.needsNoSuchMethodHandling(selector, this);
     }
-    return canReachAll ? compiler.commonMasks.dynamicType : mask;
+    return canReachAll ? commonMasks.dynamicType : mask;
   }
 
   void addFunctionCalledInLoop(Element element) {
     functionsCalledInLoop.add(element.declaration);
   }
 
   bool isCalledInLoop(Element element) {
     return functionsCalledInLoop.contains(element.declaration);
   }
 
   bool fieldNeverChanges(Element element) {
     if (!element.isField) return false;
     if (backend.isNative(element)) {
       // Some native fields are views of data that may be changed by operations.
       // E.g. node.firstChild depends on parentNode.removeBefore(n1, n2).
       // TODO(sra): Refine the effect classification so that native effects are
       // distinct from ordinary Dart effects.
       return false;
     }
 
     if (element.isFinal || element.isConst) {
       return true;
     }
     if (element.isInstanceMember) {
-      return !compiler.resolverWorld.hasInvokedSetter(element, this) &&
-          !compiler.resolverWorld.fieldSetters.contains(element);
+      return !_compiler.resolverWorld.hasInvokedSetter(element, this) &&
+          !_compiler.resolverWorld.fieldSetters.contains(element);
     }
     return false;
   }
 
   SideEffects getSideEffectsOfElement(Element element) {
     // The type inferrer (where the side effects are being computed),
     // does not see generative constructor bodies because they are
     // created by the backend. Also, it does not make any distinction
     // between a constructor and its body for side effects. This
     // implies that currently, the side effects of a constructor body
@@ skipping 57 matching lines @@
     // method of function classes that were generated for function
     // expressions. In such a case, we have to look at the original
     // function expressions's element.
     // TODO(herhut): Generate classes for function expressions earlier.
     if (element is SynthesizedCallMethodElementX) {
       return getMightBePassedToApply(element.expression);
     }
     return functionsThatMightBePassedToApply.contains(element);
   }
 
-  bool get hasClosedWorldAssumption => !compiler.options.hasIncrementalSupport;
+  bool get hasClosedWorldAssumption => !_compiler.options.hasIncrementalSupport;
 }