Decouple TypeMask from ClassElement

pkg/compiler/lib/src/types/union_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;
 
 class UnionTypeMask implements TypeMask {
   final Iterable<FlatTypeMask> disjointMasks;
 
   static const int MAX_UNION_LENGTH = 4;
@@ skipping 76 matching lines @@
     }
   }
 
   static TypeMask flatten(List<FlatTypeMask> masks, ClosedWorld closedWorld) {
     assert(masks.length > 1);
     // If either type mask is a subtype type mask, we cannot use a
     // subclass type mask to represent their union.
     bool useSubclass = masks.every((e) => !e.isSubtype);
     bool isNullable = masks.any((e) => e.isNullable);
 
-    List<ClassElement> masksBases = masks.map((mask) => mask.base).toList();
-    Iterable<ClassElement> candidates =
-        closedWorld.commonSupertypesOf(masksBases);
+    List masksBases = masks.map((mask) => mask.base).toList();
+    Iterable<Entity> candidates = closedWorld.commonSupertypesOf(masksBases);
 
     // Compute the best candidate and its kind.
-    ClassElement bestElement;
+    Entity bestElement;
     int bestKind;
     int bestSize;
-    for (ClassElement candidate in candidates) {
+    for (Entity candidate in candidates) {
       bool isInstantiatedStrictSubclass(cls) =>
           cls != candidate &&
           closedWorld.isDirectlyInstantiated(cls) &&
           closedWorld.isSubclassOf(cls, candidate);
 
       int size;
       int kind;
       if (useSubclass && masksBases.every(isInstantiatedStrictSubclass)) {
         // If both [this] and [other] are subclasses of the supertype,
         // then we prefer to construct a subclass type mask because it
@@ skipping 108 matching lines @@
     // The fast test is precise for exact types.
     if (other.isExact) return false;
     // We cannot contain object.
     if (other.contains(closedWorld.coreClasses.objectClass, closedWorld)) {
       return false;
     }
     FlatTypeMask flat = TypeMask.nonForwardingMask(other);
     // Check we cover the base class.
     if (!contains(flat.base, closedWorld)) return false;
     // Check for other members.
-    Iterable<ClassElement> members;
+    Iterable<Entity> members;
     if (flat.isSubclass) {
       members = closedWorld.strictSubclassesOf(flat.base);
     } else {
       assert(flat.isSubtype);
       members = closedWorld.strictSubtypesOf(flat.base);
     }
-    return members.every((ClassElement cls) => this.contains(cls, closedWorld));
+    return members.every((Entity cls) => this.contains(cls, closedWorld));
   }
 
   bool isInMask(TypeMask other, ClosedWorld closedWorld) {
     other = TypeMask.nonForwardingMask(other);
     if (isNullable && !other.isNullable) return false;
     if (other.isUnion) {
       UnionTypeMask union = other;
       bool containedInAnyOf(FlatTypeMask mask, Iterable<FlatTypeMask> masks) {
         // null is not canonicalized for the union but stored only on some
         // masks in [disjointMask]. It has been checked in the surrounding
@@ skipping 47 matching lines @@
   }
 
   bool containsOnlyBool(ClosedWorld closedWorld) {
     return disjointMasks.every((mask) => mask.containsOnlyBool(closedWorld));
   }
 
   bool containsOnlyString(ClosedWorld closedWorld) {
     return disjointMasks.every((mask) => mask.containsOnlyString(closedWorld));
   }
 
-  bool containsOnly(ClassElement element) {
+  bool containsOnly(Entity element) {
     return disjointMasks.every((mask) => mask.containsOnly(element));
   }
 
-  bool satisfies(ClassElement cls, ClosedWorld closedWorld) {
+  bool satisfies(Entity cls, ClosedWorld closedWorld) {
     return disjointMasks.every((mask) => mask.satisfies(cls, closedWorld));
   }
 
-  bool contains(ClassElement type, ClosedWorld closedWorld) {
-    return disjointMasks.any((e) => e.contains(type, closedWorld));
+  bool contains(Entity cls, ClosedWorld closedWorld) {
+    return disjointMasks.any((e) => e.contains(cls, closedWorld));
   }
 
   bool containsAll(ClosedWorld closedWorld) {
     return disjointMasks.any((mask) => mask.containsAll(closedWorld));
   }
 
-  ClassElement singleClass(ClosedWorld closedWorld) => null;
+  Entity singleClass(ClosedWorld closedWorld) => null;
 
   bool needsNoSuchMethodHandling(Selector selector, ClosedWorld closedWorld) {
     return disjointMasks
         .any((e) => e.needsNoSuchMethodHandling(selector, closedWorld));
   }
 
   bool canHit(Element element, Selector selector, ClosedWorld closedWorld) {
     return disjointMasks.any((e) => e.canHit(element, selector, closedWorld));
   }
 
@@ skipping 38 matching lines @@
   int get hashCode {
     int hashCode = isNullable ? 86 : 43;
     // The order of the masks in [disjointMasks] must not affect the
     // hashCode.
     for (var mask in disjointMasks) {
       hashCode = (hashCode ^ mask.nonNullable().hashCode) & 0x3fffffff;
     }
     return hashCode;
   }
 }