Normalize type masks to use the least upper instantiated subclass/type.

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 types;
 
 /// 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 71 matching lines @@
                    ClassWorld classWorld) {
     return new FlatTypeMask.normalized(
         base, (kind << 1) | (isNullable ? 1 : 0), classWorld);
   }
 
   const factory TypeMask.empty() = FlatTypeMask.empty;
 
   factory TypeMask.exact(ClassElement base, ClassWorld classWorld) {
     assert(invariant(base, classWorld.isInstantiated(base),
         message: () => "Cannot create exact type mask for uninstantiated "
-                       "class $base.\n${classWorld.dump()}"));
+                       "class $base.\n${classWorld.dump(base)}"));
     return new FlatTypeMask.exact(base);
   }
 
   factory TypeMask.exactOrEmpty(ClassElement base, ClassWorld classWorld) {
     if (classWorld.isInstantiated(base)) return new FlatTypeMask.exact(base);
     return const TypeMask.empty();
   }
 
   factory TypeMask.subclass(ClassElement base, ClassWorld classWorld) {
-    if (classWorld.hasAnyStrictSubclass(base)) {
-      return new FlatTypeMask.subclass(base);
+    assert(invariant(base, classWorld.isInstantiated(base),
+        message: () => "Cannot create subclass type mask for uninstantiated "
+                       "class $base.\n${classWorld.dump(base)}"));
+    ClassElement topmost = classWorld.getLubOfInstantiatedSubclasses(base);
+    if (topmost == null) {
+      return new TypeMask.empty();
+    } else if (classWorld.hasAnyStrictSubclass(topmost)) {
+      return new FlatTypeMask.subclass(topmost);
     } else {
-      return new TypeMask.exactOrEmpty(base, classWorld);
+      return new TypeMask.exact(topmost, classWorld);
     }
   }
 
   factory TypeMask.subtype(ClassElement base, ClassWorld classWorld) {
-    if (classWorld.hasOnlySubclasses(base)) {
-      return new TypeMask.subclass(base, classWorld);
+    ClassElement topmost = classWorld.getLubOfInstantiatedSubtypes(base);
+    if (topmost == null) {
+      return new TypeMask.empty();
     }
-    if (classWorld.hasAnyStrictSubtype(base)) {
-      return new FlatTypeMask.subtype(base);
+    if (classWorld.hasOnlySubclasses(topmost)) {
+      return new TypeMask.subclass(topmost, classWorld);
+    }
+    if (classWorld.hasAnyStrictSubtype(topmost)) {
+      return new FlatTypeMask.subtype(topmost);
     } else {
-      return new TypeMask.exactOrEmpty(base, classWorld);
+      return new TypeMask.exact(topmost, classWorld);
     }
   }
 
   const factory TypeMask.nonNullEmpty() = FlatTypeMask.nonNullEmpty;
 
   factory TypeMask.nonNullExact(ClassElement base, ClassWorld classWorld) {
     assert(invariant(base, classWorld.isInstantiated(base),
-        message: () => "Cannot create exact type mask for "
-                 "uninstantiated class $base.\n${classWorld.dump(base)}"));
+        message: () => "Cannot create exact type mask for uninstantiated "
+                       "class $base.\n${classWorld.dump(base)}"));
     return new FlatTypeMask.nonNullExact(base);
   }
 
   factory TypeMask.nonNullExactOrEmpty(ClassElement base,
       ClassWorld classWorld) {
     if (classWorld.isInstantiated(base)) {
       return new FlatTypeMask.nonNullExact(base);
     }
     return const TypeMask.nonNullEmpty();
   }
 
   factory TypeMask.nonNullSubclass(ClassElement base, ClassWorld classWorld) {
-    if (classWorld.hasAnyStrictSubclass(base)) {
-      return new FlatTypeMask.nonNullSubclass(base);
+    assert(invariant(base, classWorld.isInstantiated(base),
+        message: () => "Cannot create subclass type mask for uninstantiated "
+                       "class $base.\n${classWorld.dump(base)}"));
+    ClassElement topmost = classWorld.getLubOfInstantiatedSubclasses(base);
+    if (topmost == null) {
+      return new TypeMask.nonNullEmpty();
+    } else if (classWorld.hasAnyStrictSubclass(topmost)) {
+      return new FlatTypeMask.nonNullSubclass(topmost);
     } else {
-      return new TypeMask.nonNullExactOrEmpty(base, classWorld);
+      return new TypeMask.nonNullExact(topmost, classWorld);
     }
   }
 
   factory TypeMask.nonNullSubtype(ClassElement base, ClassWorld classWorld) {
-    if (classWorld.hasOnlySubclasses(base)) {
-      return new TypeMask.nonNullSubclass(base, classWorld);
+    ClassElement topmost = classWorld.getLubOfInstantiatedSubtypes(base);
+    if (topmost == null) {
+      return new TypeMask.nonNullEmpty();
     }
-    if (classWorld.hasAnyStrictSubtype(base)) {
-      return new FlatTypeMask.nonNullSubtype(base);
+    if (classWorld.hasOnlySubclasses(topmost)) {
+      return new TypeMask.nonNullSubclass(topmost, classWorld);
+    }
+    if (classWorld.hasAnyStrictSubtype(topmost)) {
+      return new FlatTypeMask.nonNullSubtype(topmost);
     } else {
-      return new TypeMask.nonNullExactOrEmpty(base, classWorld);
+      return new TypeMask.nonNullExact(topmost, classWorld);
     }
   }
 
   factory TypeMask.unionOf(Iterable<TypeMask> masks, ClassWorld classWorld) {
     return UnionTypeMask.unionOf(masks, classWorld);
   }
 
   /**
    * If [mask] is forwarding, returns the first non-forwarding [TypeMask] in
    * [mask]'s forwarding chain.
@@ skipping 167 matching lines @@
   /**
    * 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,
       TypeMask mask,
       Compiler compiler);
 }