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

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

Index: pkg/compiler/lib/src/types/type_mask.dart
diff --git a/pkg/compiler/lib/src/types/type_mask.dart b/pkg/compiler/lib/src/types/type_mask.dart
index 2f5754fd880ea1d11a3078ad17afdc385ac7a772..83f8f343207518ee6633a334f3f62e4094e09083 100644
--- a/pkg/compiler/lib/src/types/type_mask.dart
+++ b/pkg/compiler/lib/src/types/type_mask.dart
@@ -89,7 +89,7 @@ abstract class TypeMask implements ReceiverConstraint {
   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);
   }
 
@@ -99,6 +99,10 @@ abstract class TypeMask implements ReceiverConstraint {
   }
 
   factory TypeMask.subclass(ClassElement base, ClassWorld classWorld) {
+    assert(invariant(base, classWorld.isInstantiated(base),
+        message: () => "Cannot create subclass type mask for uninstantiated "
+                       "class $base.\n${classWorld.dump(base)}"));
+    base = classWorld.getLeastUpperInstantiatedSubclass(base);

[herhut, 2015/11/04 10:42:20]

Name this topmost, as well?

[Johnni Winther, 2015/11/06 13:43:23]

Done.

     if (classWorld.hasAnyStrictSubclass(base)) {
       return new FlatTypeMask.subclass(base);
     } else {
@@ -107,13 +111,17 @@ abstract class TypeMask implements ReceiverConstraint {
   }
 
   factory TypeMask.subtype(ClassElement base, ClassWorld classWorld) {
-    if (classWorld.hasOnlySubclasses(base)) {
-      return new TypeMask.subclass(base, classWorld);
+    ClassElement topmost = classWorld.getLeastUpperInstantiatedSubtype(base);
+    if (topmost == null) {
+      return new TypeMask.empty();
+    }
+    if (classWorld.hasOnlySubclasses(topmost)) {
+      return new TypeMask.subclass(topmost, classWorld);
     }
-    if (classWorld.hasAnyStrictSubtype(base)) {
-      return new FlatTypeMask.subtype(base);
+    if (classWorld.hasAnyStrictSubtype(topmost)) {
+      return new FlatTypeMask.subtype(topmost);
     } else {
-      return new TypeMask.exactOrEmpty(base, classWorld);
+      return new TypeMask.exact(topmost, classWorld);
     }
   }
 
@@ -121,8 +129,8 @@ abstract class TypeMask implements ReceiverConstraint {
 
   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);
   }
 
@@ -135,6 +143,10 @@ abstract class TypeMask implements ReceiverConstraint {
   }
 
   factory TypeMask.nonNullSubclass(ClassElement base, ClassWorld classWorld) {
+    assert(invariant(base, classWorld.isInstantiated(base),
+        message: () => "Cannot create subclass type mask for uninstantiated "
+                       "class $base.\n${classWorld.dump(base)}"));
+    base = classWorld.getLeastUpperInstantiatedSubclass(base);
     if (classWorld.hasAnyStrictSubclass(base)) {
       return new FlatTypeMask.nonNullSubclass(base);
     } else {
@@ -143,13 +155,17 @@ abstract class TypeMask implements ReceiverConstraint {
   }
 
   factory TypeMask.nonNullSubtype(ClassElement base, ClassWorld classWorld) {
-    if (classWorld.hasOnlySubclasses(base)) {
-      return new TypeMask.nonNullSubclass(base, classWorld);
+    ClassElement topmost = classWorld.getLeastUpperInstantiatedSubtype(base);
+    if (topmost == null) {
+      return new TypeMask.nonNullEmpty();
+    }
+    if (classWorld.hasOnlySubclasses(topmost)) {
+      return new TypeMask.nonNullSubclass(topmost, classWorld);
     }
-    if (classWorld.hasAnyStrictSubtype(base)) {
-      return new FlatTypeMask.nonNullSubtype(base);
+    if (classWorld.hasAnyStrictSubtype(topmost)) {
+      return new FlatTypeMask.nonNullSubtype(topmost);
     } else {
-      return new TypeMask.nonNullExactOrEmpty(base, classWorld);
+      return new TypeMask.nonNullExact(topmost, classWorld);
     }
   }