Revert "Split TypedSelector into Selector and 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 '../elements/elements.dart';
 import '../dart2jslib.dart';
 import '../dart_types.dart';
 import '../types/types.dart';
 import '../tree/tree.dart';
 import '../util/util.dart';
 
 part 'function_set.dart';
 part 'side_effects.dart';
 
-class UniverseSelector {
-  final Selector selector;
-  final TypeMask 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;
-}
-
-/// 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;
-
-  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>';
-    }
-  }
-}
-
-
-
 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 =
       new Set<ClassElement>();
@@ skipping 17 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, Set<Selector>> invokedNames =
+      new Map<String, Set<Selector>>();
+  final Map<String, Set<Selector>> invokedGetters =
+      new Map<String, Set<Selector>>();
+  final Map<String, Set<Selector>> invokedSetters =
+      new Map<String, Set<Selector>>();
 
   /**
    * 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 82 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,
-                            Element member,
-                            World world) {
+  bool hasMatchingSelector(Set<Selector> 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];
-        if (masks.applies(member, selector, world)) {
-          return true;
-        }
-      }
+    for (Selector selector in selectors) {
+      if (selector.appliesUnnamed(member, world)) return true;
     }
     return false;
   }
 
   bool hasInvocation(Element member, World world) {
-    return _hasMatchingSelector(_invokedNames[member.name], member, world);
+    return hasMatchingSelector(invokedNames[member.name], member, world);
   }
 
   bool hasInvokedGetter(Element member, World world) {
-    return _hasMatchingSelector(_invokedGetters[member.name], member, world);
+    return hasMatchingSelector(invokedGetters[member.name], member, world);
   }
 
   bool hasInvokedSetter(Element member, World world) {
-    return _hasMatchingSelector(_invokedSetters[member.name], member, world);
-  }
-
-  bool registerInvocation(UniverseSelector selector) {
-    return _registerNewSelector(selector, _invokedNames);
-  }
-
-  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) {
-    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);
-  }
-
-  Map<Selector, TypeMaskSet> invocationsByName(String name) {
-    return _invokedNames[name];
-  }
-
-  void forEachInvokedName(
-      f(String name, Map<Selector, TypeMaskSet> selectors)) {
-    _invokedNames.forEach(f);
-  }
-
-  void forEachInvokedGetter(
-      f(String name, Map<Selector, TypeMaskSet> selectors)) {
-    _invokedGetters.forEach(f);
-  }
-
-  void forEachInvokedSetter(
-      f(String name, Map<Selector, TypeMaskSet> selectors)) {
-    _invokedSetters.forEach(f);
+    return hasMatchingSelector(invokedSetters[member.name], member, world);
   }
 
   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 369 matching lines @@
                    Name name,
                    CallStructure callStructure) {
     // TODO(johnniwinther): Maybe use equality instead of implicit hashing.
     int hashCode = computeHashCode(kind, name, callStructure);
     List<Selector> list = canonicalizedValues.putIfAbsent(hashCode,
         () => <Selector>[]);
     for (int i = 0; i < list.length; i++) {
       Selector existing = list[i];
       if (existing.match(kind, name, callStructure)) {
         assert(existing.hashCode == hashCode);
+        assert(existing.mask == null);
         return existing;
       }
     }
     Selector result = new Selector.internal(
         kind, name, callStructure, hashCode);
     list.add(result);
     return result;
   }
 
   factory Selector.fromElement(Element element) {
@@ skipping 104 matching lines @@
 
   bool get isIndex => kind == SelectorKind.INDEX && argumentCount == 1;
   bool get isIndexSet => kind == SelectorKind.INDEX && argumentCount == 2;
 
   bool get isOperator => kind == SelectorKind.OPERATOR;
   bool get isUnaryOperator => isOperator && argumentCount == 0;
 
   /** Check whether this is a call to 'assert'. */
   bool get isAssert => isCall && identical(name, "assert");
 
+  bool get hasExactMask => false;
+  TypeMask get mask => null;
+  Selector get asUntyped => this;
+
   /**
    * The member name for invocation mirrors created from this selector.
    */
   String get invocationMirrorMemberName =>
       isSetter ? '$name=' : name;
 
   int get invocationMirrorKind {
     const int METHOD = 0;
     const int GETTER = 1;
     const int SETTER = 2;
@@ skipping 59 matching lines @@
   static int computeHashCode(SelectorKind kind,
                              Name name,
                              CallStructure callStructure) {
     // Add bits from name and kind.
     int hash = Hashing.mixHashCodeBits(name.hashCode, kind.hashCode);
     // Add bits from the call structure.
     return Hashing.mixHashCodeBits(hash, callStructure.hashCode);
   }
 
   String toString() {
-    return 'Selector($kind, $name, ${callStructure.structureToString()})';
+    String type = '';
+    if (mask != null) type = ', mask=$mask';
+    return 'Selector($kind, $name, ${callStructure.structureToString()}$type)';
+  }
+
+  Selector extendIfReachesAll(Compiler compiler) {
+    return new TypedSelector(
+        compiler.typesTask.dynamicType, this, compiler.world);
   }
 
   Selector toCallSelector() => new Selector.callClosureFrom(this);
 }
+
+class TypedSelector extends Selector {
+  final Selector asUntyped;
+  final TypeMask mask;
+
+  TypedSelector.internal(this.mask, Selector selector, int hashCode)
+      : asUntyped = selector,
+        super.internal(selector.kind,
+                       selector.memberName,
+                       selector.callStructure,
+                       hashCode) {
+    assert(mask != null);
+    assert(asUntyped.mask == null);
+  }
+
+
+  factory TypedSelector(TypeMask mask, Selector selector, World world) {
+    if (!world.hasClosedWorldAssumption) {
+      // TODO(johnniwinther): Improve use of TypedSelector in an open world.
+      bool isNullable = mask.isNullable;
+      mask = world.compiler.typesTask.dynamicType;
+      if (isNullable) {
+        mask = mask.nullable();
+      }
+    }
+    // TODO(johnniwinther): Allow more TypeSelector kinds during resoluton.
+    assert(world.isClosed || mask.isExact);
+    if (selector.mask == mask) return selector;
+    Selector untyped = selector.asUntyped;
+    Map<TypeMask, TypedSelector> map = world.canonicalizedValues
+        .putIfAbsent(untyped, () => new Map<TypeMask, TypedSelector>());
+    TypedSelector result = map[mask];
+    if (result == null) {
+      int hashCode = Hashing.mixHashCodeBits(untyped.hashCode, mask.hashCode);
+      result = map[mask] = new TypedSelector.internal(mask, untyped, hashCode);
+    }
+    return result;
+  }
+
+  factory TypedSelector.exact(
+      ClassElement base, Selector selector, World world)
+          => new TypedSelector(new TypeMask.exact(base, world), selector,
+              world);
+
+  factory TypedSelector.subclass(
+      ClassElement base, Selector selector, World world)
+          => new TypedSelector(new TypeMask.subclass(base, world),
+                               selector, world);
+
+  factory TypedSelector.subtype(
+      ClassElement base, Selector selector, World world)
+          => new TypedSelector(new TypeMask.subtype(base, world),
+                               selector, world);
+
+  bool appliesUnnamed(Element element, World world) {
+    assert(sameNameHack(element, world));
+    if (!mask.canHit(element, this, world)) return false;
+    return appliesUntyped(element, world);
+  }
+
+  Selector extendIfReachesAll(Compiler compiler) {
+    bool canReachAll = compiler.enabledInvokeOn
+        && mask.needsNoSuchMethodHandling(this, compiler.world);
+    return canReachAll
+        ? new TypedSelector(
+            compiler.typesTask.dynamicType, this, compiler.world)
+        : this;
+  }
+}