Decouple TypeMask from ClassElement

pkg/compiler/lib/src/types/flat_type_mask.dart

 // Copyright (c) 2013, 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.
 
 part of masks;
 
 /**
  * A flat type mask is a type mask that has been flattened to contain a
  * base type.
  */
 class FlatTypeMask implements TypeMask {
   static const int EMPTY = 0;
   static const int EXACT = 1;
   static const int SUBCLASS = 2;
   static const int SUBTYPE = 3;
 
-  final ClassElement base;
+  final Entity base;
   final int flags;
 
-  FlatTypeMask(ClassElement base, int kind, bool isNullable)
+  FlatTypeMask(Entity base, int kind, bool isNullable)
       : this.internal(base, (kind << 1) | (isNullable ? 1 : 0));
 
-  FlatTypeMask.exact(ClassElement base) : this.internal(base, (EXACT << 1) | 1);
-  FlatTypeMask.subclass(ClassElement base)
-      : this.internal(base, (SUBCLASS << 1) | 1);
-  FlatTypeMask.subtype(ClassElement base)
-      : this.internal(base, (SUBTYPE << 1) | 1);
+  FlatTypeMask.exact(Entity base) : this.internal(base, (EXACT << 1) | 1);
+  FlatTypeMask.subclass(Entity base) : this.internal(base, (SUBCLASS << 1) | 1);
+  FlatTypeMask.subtype(Entity base) : this.internal(base, (SUBTYPE << 1) | 1);
 
   const FlatTypeMask.nonNullEmpty()
       : base = null,
         flags = 0;
   const FlatTypeMask.empty()
       : base = null,
         flags = 1;
 
-  FlatTypeMask.nonNullExact(ClassElement base)
-      : this.internal(base, EXACT << 1);
-  FlatTypeMask.nonNullSubclass(ClassElement base)
+  FlatTypeMask.nonNullExact(Entity base) : this.internal(base, EXACT << 1);
+  FlatTypeMask.nonNullSubclass(Entity base)
       : this.internal(base, SUBCLASS << 1);
-  FlatTypeMask.nonNullSubtype(ClassElement base)
-      : this.internal(base, SUBTYPE << 1);
+  FlatTypeMask.nonNullSubtype(Entity base) : this.internal(base, SUBTYPE << 1);
+
+  bool _validateBase(ClassElement element) => element.isDeclaration;
 
   FlatTypeMask.internal(this.base, this.flags) {
-    assert(base == null || base.isDeclaration);
+    assert(base == null || _validateBase(base));
   }
 
   /**
    * Ensures that the generated mask is normalized, i.e., a call to
    * [TypeMask.assertIsNormalized] with the factory's result returns `true`.
    */
-  factory FlatTypeMask.normalized(
-      ClassElement base, int flags, ClosedWorld world) {
+  factory FlatTypeMask.normalized(Entity base, int flags, ClosedWorld world) {
     if ((flags >> 1) == EMPTY || ((flags >> 1) == EXACT)) {
       return new FlatTypeMask.internal(base, flags);
     }
     if ((flags >> 1) == SUBTYPE) {
       if (!world.hasAnyStrictSubtype(base) || world.hasOnlySubclasses(base)) {
         flags = (flags & 0x1) | (SUBCLASS << 1);
       }
     }
     if (((flags >> 1) == SUBCLASS) && !world.hasAnyStrictSubclass(base)) {
       flags = (flags & 0x1) | (EXACT << 1);
     }
-    Map<ClassElement, TypeMask> cachedMasks =
-        world.canonicalizedTypeMasks[flags];
-    if (cachedMasks == null) {
-      world.canonicalizedTypeMasks[flags] =
-          cachedMasks = <ClassElement, TypeMask>{};
-    }
-    return cachedMasks.putIfAbsent(
-        base, () => new FlatTypeMask.internal(base, flags));
+    return world.getCachedMask(
+        base, flags, () => new FlatTypeMask.internal(base, flags));
   }
 
   bool get isEmpty => isEmptyOrNull && !isNullable;
   bool get isNull => isEmptyOrNull && isNullable;
   bool get isEmptyOrNull => (flags >> 1) == EMPTY;
   bool get isExact => (flags >> 1) == EXACT;
   bool get isNullable => (flags & 1) != 0;
 
   bool get isUnion => false;
   bool get isContainer => false;
   bool get isMap => false;
   bool get isDictionary => false;
   bool get isForwarding => false;
   bool get isValue => false;
 
   // TODO(kasperl): Get rid of these. They should not be a visible
   // part of the implementation because they make it hard to add
   // proper union types if we ever want to.
   bool get isSubclass => (flags >> 1) == SUBCLASS;
   bool get isSubtype => (flags >> 1) == SUBTYPE;
 
   TypeMask nullable() {
     return isNullable ? this : new FlatTypeMask.internal(base, flags | 1);
   }
 
   TypeMask nonNullable() {
     return isNullable ? new FlatTypeMask.internal(base, flags & ~1) : this;
   }
 
-  bool contains(ClassElement type, ClosedWorld closedWorld) {
-    assert(type.isDeclaration);
+  bool contains(Entity other, ClosedWorld closedWorld) {
+    assert(_validateBase(other));
     if (isEmptyOrNull) {
       return false;
-    } else if (identical(base, type)) {
+    } else if (identical(base, other)) {
       return true;
     } else if (isExact) {
       return false;
     } else if (isSubclass) {
-      return closedWorld.isSubclassOf(type, base);
+      return closedWorld.isSubclassOf(other, base);
     } else {
       assert(isSubtype);
-      return closedWorld.isSubtypeOf(type, base);
+      return closedWorld.isSubtypeOf(other, base);
     }
   }
 
-  bool isSingleImplementationOf(ClassElement cls, ClosedWorld closedWorld) {
+  bool isSingleImplementationOf(Entity cls, ClosedWorld closedWorld) {
     // Special case basic types so that, for example, JSString is the
     // single implementation of String.
     // The general optimization is to realize there is only one class that
     // implements [base] and [base] is not instantiated. We however do
     // not track correctly the list of truly instantiated classes.
     BackendClasses backendClasses = closedWorld.backendClasses;
     if (containsOnlyString(closedWorld)) {
       return cls == closedWorld.coreClasses.stringClass ||
           cls == backendClasses.stringImplementation;
     }
@@ skipping 19 matching lines @@
     if (isEmptyOrNull) return isNullable ? other.isNullable : true;
     // The empty type contains no classes.
     if (other.isEmptyOrNull) return false;
     // Quick check whether to handle null.
     if (isNullable && !other.isNullable) return false;
     other = TypeMask.nonForwardingMask(other);
     // If other is union, delegate to UnionTypeMask.containsMask.
     if (other is! FlatTypeMask) return other.containsMask(this, closedWorld);
     // The other must be flat, so compare base and flags.
     FlatTypeMask flatOther = other;
-    ClassElement otherBase = flatOther.base;
+    Entity otherBase = flatOther.base;
     // If other is exact, it only contains its base.
     // TODO(herhut): Get rid of isSingleImplementationOf.
     if (flatOther.isExact) {
       return (isExact && base == otherBase) ||
           isSingleImplementationOf(otherBase, closedWorld);
     }
     // If other is subclass, this has to be subclass, as well. Unless
     // flatOther.base covers all subtypes of this. Currently, we only
     // consider object to behave that way.
     // TODO(herhut): Add check whether flatOther.base is superclass of
@@ skipping 39 matching lines @@
     return base == closedWorld.coreClasses.boolClass ||
         base == backendClasses.boolImplementation;
   }
 
   bool containsOnlyString(ClosedWorld closedWorld) {
     BackendClasses backendClasses = closedWorld.backendClasses;
     return base == closedWorld.coreClasses.stringClass ||
         base == backendClasses.stringImplementation;
   }
 
-  bool containsOnly(ClassElement cls) {
-    assert(cls.isDeclaration);
+  bool containsOnly(Entity cls) {
+    assert(_validateBase(cls));
     return base == cls;
   }
 
-  bool satisfies(ClassElement cls, ClosedWorld closedWorld) {
-    assert(cls.isDeclaration);
+  bool satisfies(Entity cls, ClosedWorld closedWorld) {
+    assert(_validateBase(cls));
     if (isEmptyOrNull) return false;
     if (closedWorld.isSubtypeOf(base, cls)) return true;
     return false;
   }
 
-  /**
-   * Returns the [ClassElement] if this type represents a single class,
-   * otherwise returns `null`.  This method is conservative.
-   */
-  ClassElement singleClass(ClosedWorld closedWorld) {
+  /// Returns the [Entity] if this type represents a single class, otherwise
+  /// returns `null`.  This method is conservative.
+  Entity singleClass(ClosedWorld closedWorld) {
     if (isEmptyOrNull) return null;
     if (isNullable) return null; // It is Null and some other class.
     if (isExact) {
       return base;
     } else if (isSubclass) {
       return closedWorld.hasAnyStrictSubclass(base) ? null : base;
     } else {
       assert(isSubtype);
       return null;
     }
@@ skipping 228 matching lines @@
   TypeMask intersectionHelper(FlatTypeMask other, ClosedWorld closedWorld) {
     assert(base != other.base);
     assert(!closedWorld.isSubclassOf(base, other.base));
     assert(!closedWorld.isSubclassOf(other.base, base));
     // If one of the masks are exact or if both of them are subclass
     // masks, then the intersection is empty.
     if (isExact || other.isExact) return intersectionEmpty(other);
     if (isSubclass && other.isSubclass) return intersectionEmpty(other);
     assert(isSubtype || other.isSubtype);
     int kind = (isSubclass || other.isSubclass) ? SUBCLASS : SUBTYPE;
+    // TODO(johnniwinther): Move this computation to [ClosedWorld].
     // Compute the set of classes that are contained in both type masks.
     Set<ClassElement> common = commonContainedClasses(this, other, closedWorld);
     if (common == null || common.isEmpty) return intersectionEmpty(other);
     // Narrow down the candidates by only looking at common classes
     // that do not have a superclass or supertype that will be a
     // better candidate.
     Iterable<ClassElement> candidates = common.where((ClassElement each) {
       bool containsSuperclass = common.contains(each.supertype.element);
       // If the superclass is also a candidate, then we don't want to
       // deal with this class. If we're only looking for a subclass we
       // know we don't have to look at the list of interfaces because
       // they can never be in the common set.
       if (containsSuperclass || kind == SUBCLASS) return !containsSuperclass;
       // Run through the direct supertypes of the class. If the common
       // set contains the direct supertype of the class, we ignore the
       // the class because the supertype is a better candidate.
       for (Link link = each.interfaces; !link.isEmpty; link = link.tail) {
         if (common.contains(link.head.element)) return false;
       }
       return true;
     });
     // Run through the list of candidates and compute the union. The
     // result will only be nullable if both masks are nullable. We have
     // to normalize here, as we generate types based on new base classes.
     int combined = (kind << 1) | (flags & other.flags & 1);
-    Iterable<TypeMask> masks = candidates.map((ClassElement cls) {
+    Iterable<TypeMask> masks = candidates.map((Entity cls) {
       return new FlatTypeMask.normalized(cls, combined, closedWorld);
     });
     return UnionTypeMask.unionOf(masks, closedWorld);
   }
 
   TypeMask intersectionEmpty(FlatTypeMask other) {
     return isNullable && other.isNullable
         ? new TypeMask.empty()
         : new TypeMask.nonNullEmpty();
   }
 
   /**
-   * Returns whether [element] will be the one used at runtime when being
-   * invoked on an instance of [cls]. [selector] is used to ensure library
-   * privacy is taken into account.
-   */
-  static bool hasElementIn(
-      ClassElement cls, Selector selector, Element element) {
-    // Use [:implementation:] of [element]
-    // because our function set only stores declarations.
-    Element result = findMatchIn(cls, selector);
-    return result == null
-        ? false
-        : result.implementation == element.implementation;
-  }
-
-  static Element findMatchIn(ClassElement cls, Selector selector) {
-    // Use the [:implementation] of [cls] in case the found [element]
-    // is in the patch class.
-    return cls.implementation.lookupByName(selector.memberName);
-  }
-
-  /**
    * Returns whether [element] is a potential target when being
    * invoked on this type mask. [selector] is used to ensure library
    * privacy is taken into account.
    */
   bool canHit(Element element, Selector selector, ClosedWorld closedWorld) {
     BackendClasses backendClasses = closedWorld.backendClasses;
     assert(element.name == selector.name);
     if (isEmpty) return false;
     if (isNull) {
-      return hasElementIn(backendClasses.nullImplementation, selector, element);
+      return closedWorld.hasElementIn(
+          backendClasses.nullImplementation, selector, element);
     }
 
     // TODO(kasperl): Can't we just avoid creating typed selectors
     // based of function types?
     Element self = base;
     if (self.isTypedef) {
       // A typedef is a function type that doesn't have any
       // user-defined members.
       return false;
     }
 
     ClassElement other = element.enclosingClass;
     if (other == backendClasses.nullImplementation) {
       return isNullable;
     } else if (isExact) {
-      return hasElementIn(self, selector, element);
+      return closedWorld.hasElementIn(self, selector, element);
     } else if (isSubclass) {
-      return hasElementIn(self, selector, element) ||
+      return closedWorld.hasElementIn(self, selector, element) ||
           other.isSubclassOf(self) ||
           closedWorld.hasAnySubclassThatMixes(self, other);
     } else {
       assert(isSubtype);
-      bool result = hasElementIn(self, selector, element) ||
+      bool result = closedWorld.hasElementIn(self, selector, element) ||
           other.implementsInterface(self) ||
           closedWorld.hasAnySubclassThatImplements(other, base) ||
           closedWorld.hasAnySubclassOfMixinUseThatImplements(other, base);
       if (result) return true;
       // If the class is used as a mixin, we have to check if the element
       // can be hit from any of the mixin applications.
       Iterable<ClassElement> mixinUses = closedWorld.mixinUsesOf(self);
       return mixinUses.any((mixinApplication) =>
-          hasElementIn(mixinApplication, selector, element) ||
+          closedWorld.hasElementIn(mixinApplication, selector, element) ||
           other.isSubclassOf(mixinApplication) ||
           closedWorld.hasAnySubclassThatMixes(mixinApplication, other));
     }
   }
 
-  /**
-   * Returns whether a [selector] call on an instance of [cls]
-   * will hit a method at runtime, and not go through [noSuchMethod].
-   */
-  static bool hasConcreteMatch(
-      ClassElement cls, Selector selector, ClosedWorld world) {
-    assert(invariant(cls, world.isInstantiated(cls),
-        message: '$cls has not been instantiated.'));
-    Element element = findMatchIn(cls, selector);
-    if (element == null) return false;
-
-    if (element.isAbstract) {
-      ClassElement enclosingClass = element.enclosingClass;
-      return hasConcreteMatch(enclosingClass.superclass, selector, world);
-    }
-    return selector.appliesUntyped(element);
-  }
-
   bool needsNoSuchMethodHandling(Selector selector, ClosedWorld closedWorld) {
     // A call on an empty type mask is either dead code, or a call on
     // `null`.
     if (isEmptyOrNull) return false;
     // A call on an exact mask for an abstract class is dead code.
-    if (isExact && base.isAbstract) return false;
-    // If the receiver is guaranteed to have a member that
-    // matches what we're looking for, there's no need to
-    // introduce a noSuchMethod handler. It will never be called.
-    //
-    // As an example, consider this class hierarchy:
-    //
-    //                   A    <-- noSuchMethod
-    //                  / \
-    //                 C   B  <-- foo
-    //
-    // If we know we're calling foo on an object of type B we
-    // don't have to worry about the noSuchMethod method in A
-    // because objects of type B implement foo. On the other hand,
-    // if we end up calling foo on something of type C we have to
-    // add a handler for it.
+    // TODO(johnniwinther): A type mask cannot be abstract. Remove the need
+    // for this noise (currently used for super-calls in inference and mirror
+    // usage).
+    if (isExact && closedWorld.isAbstract(base)) return false;
 
-    // If the holders of all user-defined noSuchMethod
-    // implementations that might be applicable to the receiver
-    // type have a matching member for the current name and
-    // selector, we avoid introducing a noSuchMethod handler.
-    //
-    // As an example, consider this class hierarchy:
-    //
-    //                       A    <-- foo
-    //                      / \
-    //   noSuchMethod -->  B   C  <-- bar
-    //                     |   |
-    //                     C   D  <-- noSuchMethod
-    //
-    // When calling foo on an object of type A, we know that the
-    // implementations of noSuchMethod are in the classes B and D
-    // that also (indirectly) implement foo, so we do not need a
-    // handler for it.
-    //
-    // If we're calling bar on an object of type D, we don't need
-    // the handler either because all objects of type D implement
-    // bar through inheritance.
-    //
-    // If we're calling bar on an object of type A we do need the
-    // handler because we may have to call B.noSuchMethod since B
-    // does not implement bar.
-
-    /// Returns `true` if [cls] is an instantiated class that does not have
-    /// a concrete method matching [selector].
-    bool needsNoSuchMethod(ClassElement cls) {
-      // We can skip uninstantiated subclasses.
-      // TODO(johnniwinther): Put filtering into the (Class)World.
-      if (!closedWorld.isInstantiated(cls)) {
-        return false;
-      }
-      // We can just skip abstract classes because we know no
-      // instance of them will be created at runtime, and
-      // therefore there is no instance that will require
-      // [noSuchMethod] handling.
-      return !cls.isAbstract && !hasConcreteMatch(cls, selector, closedWorld);
-    }
-
-    bool baseNeedsNoSuchMethod = needsNoSuchMethod(base);
-    if (isExact || baseNeedsNoSuchMethod) {
-      return baseNeedsNoSuchMethod;
-    }
-
-    Iterable<ClassElement> subclassesToCheck;
-    if (isSubtype) {
-      subclassesToCheck = closedWorld.strictSubtypesOf(base);
-    } else {
-      assert(isSubclass);
-      subclassesToCheck = closedWorld.strictSubclassesOf(base);
-    }
-
-    return subclassesToCheck != null &&
-        subclassesToCheck.any(needsNoSuchMethod);
+    return closedWorld.needsNoSuchMethod(
+        base,
+        selector,
+        isExact
+            ? ClassQuery.EXACT
+            : (isSubclass ? ClassQuery.SUBCLASS : ClassQuery.SUBTYPE));
   }
 
   Element locateSingleElement(Selector selector, Compiler compiler) {
     if (isEmptyOrNull) return null;
     Iterable<Element> targets =
         compiler.closedWorld.allFunctions.filter(selector, this);
     if (targets.length != 1) return null;
     Element result = targets.first;
-    ClassElement enclosing = result.enclosingClass;
+    ClassElement enclosing = result.enclosingClass.declaration;
     // We only return the found element if it is guaranteed to be implemented on
     // all classes in the receiver type [this]. It could be found only in a
     // subclass or in an inheritance-wise unrelated class in case of subtype
     // selectors.
     ClosedWorld closedWorld = compiler.closedWorld;
     if (isSubtype) {
       // if (closedWorld.isUsedAsMixin(enclosing)) {
       if (closedWorld.everySubtypeIsSubclassOfOrMixinUseOf(base, enclosing)) {
         return result;
       }
       //}
       return null;
     } else {
-      if (base.isSubclassOf(enclosing)) return result;
+      if (closedWorld.isSubclassOf(base, enclosing)) return result;
       if (closedWorld.isSubclassOfMixinUseOf(base, enclosing)) return result;
     }
     return null;
   }
 
   bool operator ==(var other) {
     if (identical(this, other)) return true;
     if (other is! FlatTypeMask) return false;
     FlatTypeMask otherMask = other;
     return (flags == otherMask.flags) && (base == otherMask.base);
@@ skipping 29 matching lines @@
     if (x.isExact) {
       return null;
     } else if (x.isSubclass) {
       return closedWorld.strictSubclassesOf(element);
     } else {
       assert(x.isSubtype);
       return closedWorld.strictSubtypesOf(element);
     }
   }
 }