Use entities in all masks.

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

Index: pkg/compiler/lib/src/types/union_type_mask.dart
diff --git a/pkg/compiler/lib/src/types/union_type_mask.dart b/pkg/compiler/lib/src/types/union_type_mask.dart
index 40305ccffac9ade677ab8f2caa6f6b925b85058d..2832b75e8cb508ec5969ad5411f2179216546dc6 100644
--- a/pkg/compiler/lib/src/types/union_type_mask.dart
+++ b/pkg/compiler/lib/src/types/union_type_mask.dart
@@ -97,13 +97,14 @@ class UnionTypeMask implements TypeMask {
     bool isNullable = masks.any((e) => e.isNullable);
 
     List masksBases = masks.map((mask) => mask.base).toList();
-    Iterable<Entity> candidates = closedWorld.commonSupertypesOf(masksBases);
+    Iterable<ClassEntity> candidates =
+        closedWorld.commonSupertypesOf(masksBases);
 
     // Compute the best candidate and its kind.
-    Entity bestElement;
+    ClassEntity bestElement;
     int bestKind;
     int bestSize;
-    for (Entity candidate in candidates) {
+    for (ClassEntity candidate in candidates) {
       bool isInstantiatedStrictSubclass(cls) =>
           cls != candidate &&
           closedWorld.isExplicitlyInstantiated(cls) &&
@@ -232,14 +233,14 @@ class UnionTypeMask implements TypeMask {
     // Check we cover the base class.
     if (!contains(flat.base, closedWorld)) return false;
     // Check for other members.
-    Iterable<Entity> members;
+    Iterable<ClassEntity> members;
     if (flat.isSubclass) {
       members = closedWorld.strictSubclassesOf(flat.base);
     } else {
       assert(flat.isSubtype);
       members = closedWorld.strictSubtypesOf(flat.base);
     }
-    return members.every((Entity cls) => this.contains(cls, closedWorld));
+    return members.every((ClassEntity cls) => this.contains(cls, closedWorld));
   }
 
   bool isInMask(TypeMask other, ClosedWorld closedWorld) {
@@ -307,15 +308,15 @@ class UnionTypeMask implements TypeMask {
     return disjointMasks.every((mask) => mask.containsOnlyString(closedWorld));
   }
 
-  bool containsOnly(Entity element) {
+  bool containsOnly(ClassEntity element) {
     return disjointMasks.every((mask) => mask.containsOnly(element));
   }
 
-  bool satisfies(Entity cls, ClosedWorld closedWorld) {
+  bool satisfies(ClassEntity cls, ClosedWorld closedWorld) {
     return disjointMasks.every((mask) => mask.satisfies(cls, closedWorld));
   }
 
-  bool contains(Entity cls, ClosedWorld closedWorld) {
+  bool contains(ClassEntity cls, ClosedWorld closedWorld) {
     return disjointMasks.any((e) => e.contains(cls, closedWorld));
   }
 
@@ -323,7 +324,7 @@ class UnionTypeMask implements TypeMask {
     return disjointMasks.any((mask) => mask.containsAll(closedWorld));
   }
 
-  Entity singleClass(ClosedWorld closedWorld) => null;
+  ClassEntity singleClass(ClosedWorld closedWorld) => null;
 
   bool needsNoSuchMethodHandling(Selector selector, ClosedWorld closedWorld) {
     return disjointMasks
@@ -331,15 +332,14 @@ class UnionTypeMask implements TypeMask {
   }
 
   bool canHit(
-      MemberElement element, Selector selector, ClosedWorld closedWorld) {
+      MemberEntity element, Selector selector, ClosedWorld closedWorld) {
     return disjointMasks.any((e) => e.canHit(element, selector, closedWorld));
   }
 
-  MemberElement locateSingleElement(
-      Selector selector, ClosedWorld closedWorld) {
-    MemberElement candidate;
+  MemberEntity locateSingleElement(Selector selector, ClosedWorld closedWorld) {
+    MemberEntity candidate;
     for (FlatTypeMask mask in disjointMasks) {
-      MemberElement current = mask.locateSingleElement(selector, closedWorld);
+      MemberEntity current = mask.locateSingleElement(selector, closedWorld);
       if (current == null) {
         return null;
       } else if (candidate == null) {