Decouple TypeMask from ClassElement

pkg/compiler/lib/src/types/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;
 
 /// An implementation of a [UniverseSelectorConstraints] that is consists if an only
 /// increasing set of [TypeMask]s, that is, once a mask is added it cannot be
 /// removed.
 class IncreasingTypeMaskSet extends UniverseSelectorConstraints {
@@ skipping 59 matching lines @@
   }
 }
 
 /**
  * A type mask represents a set of contained classes, but the
  * operations on it are not guaranteed to be precise and they may
  * yield conservative answers that contain too many classes.
  */
 abstract class TypeMask implements ReceiverConstraint, AbstractValue {
   factory TypeMask(
-      ClassElement base, int kind, bool isNullable, ClosedWorld closedWorld) {
+      Entity base, int kind, bool isNullable, ClosedWorld closedWorld) {
     return new FlatTypeMask.normalized(
         base, (kind << 1) | (isNullable ? 1 : 0), closedWorld);
   }
 
   const factory TypeMask.empty() = FlatTypeMask.empty;
 
-  factory TypeMask.exact(ClassElement base, ClosedWorld closedWorld) {
+  factory TypeMask.exact(Entity base, ClosedWorld closedWorld) {
     assert(invariant(base, closedWorld.isInstantiated(base),
         message: () => "Cannot create exact type mask for uninstantiated "
             "class $base.\n${closedWorld.dump(base)}"));
     return new FlatTypeMask.exact(base);
   }
 
-  factory TypeMask.exactOrEmpty(ClassElement base, ClosedWorld closedWorld) {
+  factory TypeMask.exactOrEmpty(Entity base, ClosedWorld closedWorld) {
     if (closedWorld.isInstantiated(base)) return new FlatTypeMask.exact(base);
     return const TypeMask.empty();
   }
 
-  factory TypeMask.subclass(ClassElement base, ClosedWorld closedWorld) {
+  factory TypeMask.subclass(Entity base, ClosedWorld closedWorld) {
     assert(invariant(base, closedWorld.isInstantiated(base),
         message: () => "Cannot create subclass type mask for uninstantiated "
             "class $base.\n${closedWorld.dump(base)}"));
-    ClassElement topmost = closedWorld.getLubOfInstantiatedSubclasses(base);
+    Entity topmost = closedWorld.getLubOfInstantiatedSubclasses(base);
     if (topmost == null) {
       return new TypeMask.empty();
     } else if (closedWorld.hasAnyStrictSubclass(topmost)) {
       return new FlatTypeMask.subclass(topmost);
     } else {
       return new TypeMask.exact(topmost, closedWorld);
     }
   }
 
-  factory TypeMask.subtype(ClassElement base, ClosedWorld closedWorld) {
-    ClassElement topmost = closedWorld.getLubOfInstantiatedSubtypes(base);
+  factory TypeMask.subtype(Entity base, ClosedWorld closedWorld) {
+    Entity topmost = closedWorld.getLubOfInstantiatedSubtypes(base);
     if (topmost == null) {
       return new TypeMask.empty();
     }
     if (closedWorld.hasOnlySubclasses(topmost)) {
       return new TypeMask.subclass(topmost, closedWorld);
     }
     if (closedWorld.hasAnyStrictSubtype(topmost)) {
       return new FlatTypeMask.subtype(topmost);
     } else {
       return new TypeMask.exact(topmost, closedWorld);
     }
   }
 
   const factory TypeMask.nonNullEmpty() = FlatTypeMask.nonNullEmpty;
 
-  factory TypeMask.nonNullExact(ClassElement base, ClosedWorld closedWorld) {
+  factory TypeMask.nonNullExact(Entity base, ClosedWorld closedWorld) {
     assert(invariant(base, closedWorld.isInstantiated(base),
         message: () => "Cannot create exact type mask for uninstantiated "
             "class $base.\n${closedWorld.dump(base)}"));
     return new FlatTypeMask.nonNullExact(base);
   }
 
-  factory TypeMask.nonNullExactOrEmpty(
-      ClassElement base, ClosedWorld closedWorld) {
+  factory TypeMask.nonNullExactOrEmpty(Entity base, ClosedWorld closedWorld) {
     if (closedWorld.isInstantiated(base)) {
       return new FlatTypeMask.nonNullExact(base);
     }
     return const TypeMask.nonNullEmpty();
   }
 
-  factory TypeMask.nonNullSubclass(ClassElement base, ClosedWorld closedWorld) {
+  factory TypeMask.nonNullSubclass(Entity base, ClosedWorld closedWorld) {
     assert(invariant(base, closedWorld.isInstantiated(base),
         message: () => "Cannot create subclass type mask for uninstantiated "
             "class $base.\n${closedWorld.dump(base)}"));
-    ClassElement topmost = closedWorld.getLubOfInstantiatedSubclasses(base);
+    Entity topmost = closedWorld.getLubOfInstantiatedSubclasses(base);
     if (topmost == null) {
       return new TypeMask.nonNullEmpty();
     } else if (closedWorld.hasAnyStrictSubclass(topmost)) {
       return new FlatTypeMask.nonNullSubclass(topmost);
     } else {
       return new TypeMask.nonNullExact(topmost, closedWorld);
     }
   }
 
-  factory TypeMask.nonNullSubtype(ClassElement base, ClosedWorld closedWorld) {
-    ClassElement topmost = closedWorld.getLubOfInstantiatedSubtypes(base);
+  factory TypeMask.nonNullSubtype(Entity base, ClosedWorld closedWorld) {
+    Entity topmost = closedWorld.getLubOfInstantiatedSubtypes(base);
     if (topmost == null) {
       return new TypeMask.nonNullEmpty();
     }
     if (closedWorld.hasOnlySubclasses(topmost)) {
       return new TypeMask.nonNullSubclass(topmost, closedWorld);
     }
     if (closedWorld.hasAnyStrictSubtype(topmost)) {
       return new FlatTypeMask.nonNullSubtype(topmost);
     } else {
       return new TypeMask.nonNullExact(topmost, closedWorld);
@@ skipping 109 matching lines @@
   bool get isForwarding;
 
   /// Returns `true` if this mask holds encodes an exact value within a type.
   bool get isValue;
 
   bool containsOnlyInt(ClosedWorld closedWorld);
   bool containsOnlyDouble(ClosedWorld closedWorld);
   bool containsOnlyNum(ClosedWorld closedWorld);
   bool containsOnlyBool(ClosedWorld closedWorld);
   bool containsOnlyString(ClosedWorld closedWorld);
-  bool containsOnly(ClassElement element);
+  bool containsOnly(Entity cls);
 
   /**
    * Compares two [TypeMask] objects for structural equality.
    *
    * Note: This may differ from semantic equality in the set containment sense.
    *   Use [containsMask] and [isInMask] for that, instead.
    */
   bool operator ==(other);
 
   /**
    * If this returns `true`, [other] is guaranteed to be a supertype of this
    * mask, i.e., this mask is in [other]. However, the inverse does not hold.
    * Enable [UnionTypeMask.PERFORM_EXTRA_CONTAINS_CHECK] to be notified of
    * false negatives.
    */
   bool isInMask(TypeMask other, ClosedWorld closedWorld);
 
   /**
    * If this returns `true`, [other] is guaranteed to be a subtype of this mask,
    * i.e., this mask contains [other]. However, the inverse does not hold.
    * Enable [UnionTypeMask.PERFORM_EXTRA_CONTAINS_CHECK] to be notified of
    * false negatives.
    */
   bool containsMask(TypeMask other, ClosedWorld closedWorld);
 
   /**
    * Returns whether this type mask is an instance of [cls].
    */
-  bool satisfies(ClassElement cls, ClosedWorld closedWorld);
+  bool satisfies(Entity cls, ClosedWorld closedWorld);
 
   /**
-   * Returns whether or not this type mask contains the given type.
+   * Returns whether or not this type mask contains the given class [cls].
    */
-  bool contains(ClassElement type, ClosedWorld closedWorld);
+  bool contains(Entity cls, ClosedWorld closedWorld);
 
   /**
    * Returns whether or not this type mask contains all types.
    */
   bool containsAll(ClosedWorld closedWorld);
 
-  /**
-   * 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);
 
   /**
    * Returns a type mask representing the union of [this] and [other].
    */
   TypeMask union(TypeMask other, ClosedWorld closedWorld);
 
   /// Returns whether the intersection of this and [other] is empty.
   bool isDisjoint(TypeMask other, ClosedWorld closedWorld);
 
   /**
    * Returns a type mask representing the intersection of [this] and [other].
    */
   TypeMask intersection(TypeMask other, ClosedWorld closedWorld);
 
   /**
    * 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);
 
   /**
    * Returns the [element] that is known to always be hit at runtime
    * on this mask. Returns null if there is none.
    */
   // TODO(johnniwinther): Move this method to [World].
   Element locateSingleElement(Selector selector, Compiler compiler);
 }