Rename ReceiverMask and ReceiverMaskSet and update comments.

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/names.dart' show
     Identifiers,
@@ skipping 15 matching lines @@
     World;
 
 import 'call_structure.dart';
 import 'selector.dart' show
     Selector;
 import 'function_set.dart';
 import 'side_effects.dart';
 
 class UniverseSelector {
   final Selector selector;
-  final ReceiverMask mask;
+  final ReceiverConstraint mask;
 
   UniverseSelector(this.selector, this.mask);
 
   bool appliesUnnamed(Element element, ClassWorld world) {
     return selector.appliesUnnamed(element, world) &&
         (mask == null || mask.canHit(element, selector, world));
   }
 
   String toString() => '$selector,$mask';
 }
 
-/// A potential receiver for a dynamic call site.
-abstract class ReceiverMask {
+/// 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 this receiver mask. [selector] is used to ensure library
-  /// privacy is taken into account.
+  /// 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);
 }
 
-/// A set of potential receivers for the dynamic call sites of the same
+/// The combined constraints on receivers all the dynamic call sites of the same
 /// selector.
 ///
 /// For instance for these calls
 ///
+///     class A {
+///        foo(a, b) {}
+///     }
+///     class B {
+///        foo(a, b) {}
+///     }
+///     class C {
+///        foo(a, b) {}
+///     }
 ///     new A().foo(a, b);
 ///     new B().foo(0, 42);
 ///
-/// the receiver mask set for dynamic calls to 'foo' with to positional
-/// arguments will contain receiver masks abstracting `new A()` and `new B()`.
-abstract class ReceiverMaskSet {
-  /// Returns `true` if [selector] applies to any of the potential receivers
-  /// in this set given the closed [world].
+/// the selector constaints for dynamic calls to 'foo' with two positional
+/// arguments could be 'receiver of exact instance `A` or `B`'.
+abstract class SelectorConstraints {
+  /// Returns `true` if [selector] applies to [element] under these constraints
+  /// given the closed [world].
+  ///
+  /// Consider for instance in this world:
+  ///
+  ///     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);
 
-  /// Returns `true` if any potential receivers in this set given the closed
-  /// [world] have no implementation matching [selector].
+  /// 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()` have no implementation of `foo` and thus
-  /// needs to handle the call though its `noSuchMethod` handler.
+  /// 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);
 }
 
-/// A mutable [ReceiverMaskSet] used in [Universe].
-abstract class UniverseReceiverMaskSet extends ReceiverMaskSet {
-  /// Adds [mask] to this set of potential receivers. Return `true` if the
-  /// set expanded due to the new mask.
-  bool addReceiverMask(ReceiverMask mask);
+/// 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 potential receivers of dynamic call sites.
-abstract class ReceiverMaskStrategy {
-  /// Create a [UniverseReceiverMaskSet] to represent the potential receiver for
-  /// a dynamic call site with [selector].
-  UniverseReceiverMaskSet createReceiverMaskSet(Selector selector);
+/// 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);
 }
 
 class Universe {
   /// The set of all directly instantiated classes, that is, classes with a
   /// generative constructor that has been called directly and not only through
   /// a super-call.
   ///
   /// Invariant: Elements are declaration elements.
   // TODO(johnniwinther): [_directlyInstantiatedClasses] and
   // [_instantiatedTypes] sets should be merged.
@@ skipping 19 matching lines @@
 
   /**
    * Documentation wanted -- johnniwinther
    *
    * Invariant: Elements are declaration elements.
    */
   final Set<FunctionElement> staticFunctionsNeedingGetter =
       new Set<FunctionElement>();
   final Set<FunctionElement> methodsNeedingSuperGetter =
       new Set<FunctionElement>();
-  final Map<String, Map<Selector, ReceiverMaskSet>> _invokedNames =
-      <String, Map<Selector, ReceiverMaskSet>>{};
-  final Map<String, Map<Selector, ReceiverMaskSet>> _invokedGetters =
-      <String, Map<Selector, ReceiverMaskSet>>{};
-  final Map<String, Map<Selector, ReceiverMaskSet>> _invokedSetters =
-      <String, Map<Selector, ReceiverMaskSet>>{};
+  final Map<String, Map<Selector, SelectorConstraints>> _invokedNames =
+      <String, Map<Selector, SelectorConstraints>>{};
+  final Map<String, Map<Selector, SelectorConstraints>> _invokedGetters =
+      <String, Map<Selector, SelectorConstraints>>{};
+  final Map<String, Map<Selector, SelectorConstraints>> _invokedSetters =
+      <String, Map<Selector, SelectorConstraints>>{};
 
   /**
    * Fields accessed. Currently only the codegen knows this
    * information. The resolver is too conservative when seeing a
    * getter and only registers an invoked getter.
    */
   final Set<Element> fieldGetters = new Set<Element>();
 
   /**
    * Fields set. See comment in [fieldGetters].
@@ skipping 21 matching lines @@
    * to find all live closure instances.
    */
   final Set<LocalFunctionElement> allClosures = new Set<LocalFunctionElement>();
 
   /**
    * Set of methods in instantiated classes that are potentially
    * closurized.
    */
   final Set<Element> closurizedMembers = new Set<Element>();
 
-  final ReceiverMaskStrategy receiverMaskStrategy;
+  final SelectorConstraintsStrategy selectorConstraintsStrategy;
 
-  Universe(this.receiverMaskStrategy);
+  Universe(this.selectorConstraintsStrategy);
 
   /// 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 {
     return _directlyInstantiatedClasses;
   }
 
   /// All instantiated classes, either directly, as superclasses or as
@@ skipping 42 matching lines @@
       _directlyInstantiatedClasses.add(cls);
     }
 
     // TODO(johnniwinther): Replace this by separate more specific mappings.
     if (!_allInstantiatedClasses.add(cls)) return;
     cls.allSupertypes.forEach((InterfaceType supertype) {
       _allInstantiatedClasses.add(supertype.element);
     });
   }
 
-  bool _hasMatchingSelector(Map<Selector, ReceiverMaskSet> selectors,
+  bool _hasMatchingSelector(Map<Selector, SelectorConstraints> selectors,
                             Element member,
                             World world) {
     if (selectors == null) return false;
     for (Selector selector in selectors.keys) {
       if (selector.appliesUnnamed(member, world)) {
-        ReceiverMaskSet masks = selectors[selector];
+        SelectorConstraints masks = selectors[selector];
         if (masks.applies(member, selector, world)) {
           return true;
         }
       }
     }
     return false;
   }
 
   bool hasInvocation(Element member, World world) {
     return _hasMatchingSelector(_invokedNames[member.name], member, world);
@@ skipping 14 matching lines @@
   bool registerInvokedGetter(UniverseSelector selector) {
     return _registerNewSelector(selector, _invokedGetters);
   }
 
   bool registerInvokedSetter(UniverseSelector selector) {
     return _registerNewSelector(selector, _invokedSetters);
   }
 
   bool _registerNewSelector(
       UniverseSelector universeSelector,
-      Map<String, Map<Selector, ReceiverMaskSet>> selectorMap) {
+      Map<String, Map<Selector, SelectorConstraints>> selectorMap) {
     Selector selector = universeSelector.selector;
     String name = selector.name;
-    ReceiverMask mask = universeSelector.mask;
-    Map<Selector, ReceiverMaskSet> selectors = selectorMap.putIfAbsent(
-        name, () => new Maplet<Selector, ReceiverMaskSet>());
-    UniverseReceiverMaskSet masks = selectors.putIfAbsent(
-        selector, () => receiverMaskStrategy.createReceiverMaskSet(selector));
-    return masks.addReceiverMask(mask);
+    ReceiverConstraint mask = universeSelector.mask;
+    Map<Selector, SelectorConstraints> selectors = selectorMap.putIfAbsent(
+        name, () => new Maplet<Selector, SelectorConstraints>());
+    UniverseSelectorConstraints constraints = selectors.putIfAbsent(
+        selector, () => selectorConstraintsStrategy.createSelectorConstraints(selector));
+    return constraints.addReceiverConstraint(mask);
   }
 
-  Map<Selector, ReceiverMaskSet> _asUnmodifiable(
-      Map<Selector, ReceiverMaskSet> map) {
+  Map<Selector, SelectorConstraints> _asUnmodifiable(
+      Map<Selector, SelectorConstraints> map) {
     if (map == null) return null;
     return new UnmodifiableMapView(map);
   }
 
-  Map<Selector, ReceiverMaskSet> invocationsByName(String name) {
+  Map<Selector, SelectorConstraints> invocationsByName(String name) {
     return _asUnmodifiable(_invokedNames[name]);
   }
 
-  Map<Selector, ReceiverMaskSet> getterInvocationsByName(String name) {
+  Map<Selector, SelectorConstraints> getterInvocationsByName(String name) {
     return _asUnmodifiable(_invokedGetters[name]);
   }
 
-  Map<Selector, ReceiverMaskSet> setterInvocationsByName(String name) {
+  Map<Selector, SelectorConstraints> setterInvocationsByName(String name) {
     return _asUnmodifiable(_invokedSetters[name]);
   }
 
   void forEachInvokedName(
-      f(String name, Map<Selector, ReceiverMaskSet> selectors)) {
+      f(String name, Map<Selector, SelectorConstraints> selectors)) {
     _invokedNames.forEach(f);
   }
 
   void forEachInvokedGetter(
-      f(String name, Map<Selector, ReceiverMaskSet> selectors)) {
+      f(String name, Map<Selector, SelectorConstraints> selectors)) {
     _invokedGetters.forEach(f);
   }
 
   void forEachInvokedSetter(
-      f(String name, Map<Selector, ReceiverMaskSet> selectors)) {
+      f(String name, Map<Selector, SelectorConstraints> selectors)) {
     _invokedSetters.forEach(f);
   }
 
   DartType registerIsCheck(DartType type, Compiler compiler) {
     type = type.unalias(compiler);
     // Even in checked mode, type annotations for return type and argument
     // types do not imply type checks, so there should never be a check
     // against the type variable of a typedef.
     isChecks.add(type);
     return type;
@@ skipping 27 matching lines @@
   // TODO(ahe): Replace this method with something that is O(1), for example,
   // by using a map.
   List<LocalFunctionElement> slowDirectlyNestedClosures(Element element) {
     // Return new list to guard against concurrent modifications.
     return new List<LocalFunctionElement>.from(
         allClosures.where((LocalFunctionElement closure) {
           return closure.executableContext == element;
         }));
   }
 }