Extract ReceiverMask interface from TypeMask.

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,
     Names,
     Selectors;
 import '../compiler.dart' show
     Compiler;
 import '../diagnostics/invariant.dart' show
     invariant;
 import '../diagnostics/spannable.dart' show
     SpannableAssertionFailure;
 import '../elements/elements.dart';
 import '../dart_types.dart';
+import '../tree/tree.dart';
 import '../types/types.dart';
-import '../tree/tree.dart';
 import '../util/util.dart';
 import '../world.dart' show
     ClassWorld,
     World;
 
 part 'function_set.dart';
 part 'side_effects.dart';
 
 class UniverseSelector {
   final Selector selector;
-  final TypeMask mask;
+  final ReceiverMask 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';
 }
 
-abstract class TypeMaskSet {
-  bool applies(Element element, Selector selector, ClassWorld world);
-  Iterable<TypeMask> get masks;
+/// A potential receiver for a dynamic call site.
+abstract class ReceiverMask {
+  /// Returns whether [element] is a potential target when being
+  /// invoked on this type mask. [selector] is used to ensure library

[Siggi Cherem (dart-lang), 2015/09/01 02:12:59]

type => receiver?

[Johnni Winther, 2015/09/01 08:15:51]

Done.

+  /// privacy is taken into account.
+  bool canHit(Element element, Selector selector, ClassWorld classWorld);
 }
 
-/// An implementation of a [TypeMaskSet] that is only increasing, that is, once
-/// a mask is added it cannot be removed.
-class IncreasingTypeMaskSet extends TypeMaskSet {
-  bool isAll = false;
-  Set<TypeMask> _masks;
+/// A set of potential receivers for the dynamic call sites of the same
+/// selector.
+///
+/// For instance for these calls
+///
+///     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 {

[Siggi Cherem (dart-lang), 2015/09/01 02:12:59]

let's keep the term for now, but I wonder if "mask" is just an implementation
term we might want to use only for TypeMask?

ReceiverMarkSet could become ReceiverSet, I'm not sure what to call ReceiverMask
though.

[Johnni Winther, 2015/09/01 08:15:51]

Acknowledged.

+  /// Returns `true` if [selector] applies to any of the potential receivers
+  /// in this set given the closed [world].
+  bool applies(Element element, Selector selector, ClassWorld world);
 
-  bool applies(Element element, Selector selector, ClassWorld world) {
-    if (isAll) return true;
-    if (_masks == null) return false;
-    for (TypeMask mask in _masks) {
-      if (mask.canHit(element, selector, world)) return true;
-    }
-    return false;
-  }
-
-  bool add(TypeMask mask) {
-    if (isAll) return false;
-    if (mask == null) {
-      isAll = true;
-      _masks = null;
-      return true;
-    }
-    if (_masks == null) {
-      _masks = new Setlet<TypeMask>();
-    }
-    return _masks.add(mask);
-  }
-
-  Iterable<TypeMask> get masks {
-    if (isAll) return const [null];
-    if (_masks == null) return const [];
-    return _masks;
-  }
-
-  String toString() {
-    if (isAll) {
-      return '<all>';
-    } else if (_masks != null) {
-      return '$_masks';
-    } else {
-      return '<none>';
-    }
-  }
+  /// Returns `true` if any potential receivers in this set given 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.
+  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);

[Siggi Cherem (dart-lang), 2015/09/01 02:12:59]

if this is the main API to add a possible receiver, I wonder whether we gain
from using the ReceiverMask abstraction in this external API, or if we should
simply specify which element may become a receiver directly here:

  bool addReceiver(ClassElement element, Selector selector);

Maybe something we can brainstorm more about on our next meeting? For now I
think it's ok to submit as is.

[Johnni Winther, 2015/09/01 08:15:51]

Acknowledged.

+}
 
+/// 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);
+}
 
 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.
   final Set<ClassElement> _directlyInstantiatedClasses =
@@ skipping 18 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, TypeMaskSet>> _invokedNames =
-      <String, Map<Selector, TypeMaskSet>>{};
-  final Map<String, Map<Selector, TypeMaskSet>> _invokedGetters =
-      <String, Map<Selector, TypeMaskSet>>{};
-  final Map<String, Map<Selector, TypeMaskSet>> _invokedSetters =
-      <String, Map<Selector, TypeMaskSet>>{};
+  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>>{};
 
   /**
    * 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;
+
+  Universe(this.receiverMaskStrategy);
+
   /// 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
   /// supertypes.
@@ skipping 41 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, TypeMaskSet> selectors,
+  bool _hasMatchingSelector(Map<Selector, ReceiverMaskSet> selectors,
                             Element member,
                             World world) {
     if (selectors == null) return false;
     for (Selector selector in selectors.keys) {
       if (selector.appliesUnnamed(member, world)) {
-        TypeMaskSet masks = selectors[selector];
+        ReceiverMaskSet 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, TypeMaskSet>> selectorMap) {
+      Map<String, Map<Selector, ReceiverMaskSet>> selectorMap) {
     Selector selector = universeSelector.selector;
     String name = selector.name;
-    TypeMask mask = universeSelector.mask;
-    Map<Selector, TypeMaskSet> selectors = selectorMap.putIfAbsent(
-        name, () => new Maplet<Selector, TypeMaskSet>());
-    IncreasingTypeMaskSet masks = selectors.putIfAbsent(
-        selector, () => new IncreasingTypeMaskSet());
-    return masks.add(mask);
+    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);
   }
 
-  Map<Selector, TypeMaskSet> _asUnmodifiable(Map<Selector, TypeMaskSet> map) {
+  Map<Selector, ReceiverMaskSet> _asUnmodifiable(
+      Map<Selector, ReceiverMaskSet> map) {
     if (map == null) return null;
     return new UnmodifiableMapView(map);
   }
 
-  Map<Selector, TypeMaskSet> invocationsByName(String name) {
+  Map<Selector, ReceiverMaskSet> invocationsByName(String name) {
     return _asUnmodifiable(_invokedNames[name]);
   }
 
-  Map<Selector, TypeMaskSet> getterInvocationsByName(String name) {
+  Map<Selector, ReceiverMaskSet> getterInvocationsByName(String name) {
     return _asUnmodifiable(_invokedGetters[name]);
   }
 
-  Map<Selector, TypeMaskSet> setterInvocationsByName(String name) {
+  Map<Selector, ReceiverMaskSet> setterInvocationsByName(String name) {
     return _asUnmodifiable(_invokedSetters[name]);
   }
 
   void forEachInvokedName(
-      f(String name, Map<Selector, TypeMaskSet> selectors)) {
+      f(String name, Map<Selector, ReceiverMaskSet> selectors)) {
     _invokedNames.forEach(f);
   }
 
   void forEachInvokedGetter(
-      f(String name, Map<Selector, TypeMaskSet> selectors)) {
+      f(String name, Map<Selector, ReceiverMaskSet> selectors)) {
     _invokedGetters.forEach(f);
   }
 
   void forEachInvokedSetter(
-      f(String name, Map<Selector, TypeMaskSet> selectors)) {
+      f(String name, Map<Selector, ReceiverMaskSet> 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 570 matching lines @@
     // Add bits from the call structure.
     return Hashing.mixHashCodeBits(hash, callStructure.hashCode);
   }
 
   String toString() {
     return 'Selector($kind, $name, ${callStructure.structureToString()})';
   }
 
   Selector toCallSelector() => new Selector.callClosureFrom(this);
 }