Revert "Add superclasses, subclasses, and subtypes tracking to the world."

sdk/lib/_internal/compiler/implementation/types/type_mask.dart

Index: sdk/lib/_internal/compiler/implementation/types/type_mask.dart
diff --git a/sdk/lib/_internal/compiler/implementation/types/type_mask.dart b/sdk/lib/_internal/compiler/implementation/types/type_mask.dart
index 5bb34a35e9c0b6c40339b4faa54fbed876c6cff3..1e40622b7ee2e30205672020c7bfa8b06697a679 100644
--- a/sdk/lib/_internal/compiler/implementation/types/type_mask.dart
+++ b/sdk/lib/_internal/compiler/implementation/types/type_mask.dart
@@ -92,9 +92,8 @@ class TypeMask {
       return unionSubtype(other, compiler);
     } else if (isSubtypeOf(base, other.base, compiler)) {
       return other.unionSubtype(this, compiler);
-    } else {
-      return unionDisjoint(other, compiler);
     }
+    return null;
   }
 
   TypeMask unionSame(TypeMask other, Compiler compiler) {
@@ -146,55 +145,6 @@ class TypeMask {
         : this;
   }
 
-  TypeMask unionDisjoint(TypeMask other, Compiler compiler) {
-    assert(base != other.base);
-    assert(!isSubtypeOf(base, other.base, compiler));
-    assert(!isSubtypeOf(other.base, base, compiler));
-    // If either type mask is a subtype type mask, we cannot use a
-    // subclass type mask to represent their union.
-    bool useSubclass = !isSubtype && !other.isSubtype;
-    // Compute the common supertypes of the two types.
-    ClassElement thisElement = base.element;
-    ClassElement otherElement = other.base.element;
-    Iterable<ClassElement> candidates =
-        compiler.world.commonSupertypesOf(thisElement, otherElement);
-    if (candidates.isEmpty) return null;
-    // Compute the best candidate and its kind.
-    ClassElement bestElement;
-    int bestKind;
-    int bestSize;
-    for (ClassElement candidate in candidates) {
-      Set<ClassElement> subclasses = useSubclass
-          ? compiler.world.subclasses[candidate]
-          : null;
-      int size;
-      int kind;
-      if (subclasses != null &&
-          subclasses.contains(thisElement) &&
-          subclasses.contains(otherElement)) {
-        // If both [this] and [other] are subclasses of the supertype,
-        // then we prefer to construct a subclass type mask because it
-        // will always be at least as small as the corresponding
-        // subtype type mask.
-        kind = SUBCLASS;
-        size = subclasses.length;
-        assert(size <= compiler.world.subtypes[candidate].length);
-      } else {
-        kind = SUBTYPE;
-        size = compiler.world.subtypes[candidate].length;
-      }
-      // Update the best candidate if the new one is better.
-      if (bestElement == null || size < bestSize) {
-        bestElement = candidate;
-        bestSize = size;
-        bestKind = kind;
-      }
-    }
-    return new TypeMask(bestElement.computeType(compiler),
-                        bestKind,
-                        isNullable || other.isNullable);
-  }
-
   TypeMask intersection(TypeMask other, Compiler compiler) {
     if (base == other.base) {
       return intersectionSame(other, compiler);
@@ -275,16 +225,19 @@ class TypeMask {
     return "[$buffer]";
   }
 
+  // TODO(kasperl): Move this to the world.
   static bool isSubclassOf(DartType x, DartType y, Compiler compiler) {
     // TODO(kasperl): Do this error handling earlier.
     if (x.kind != TypeKind.INTERFACE) return false;
     if (y.kind != TypeKind.INTERFACE) return false;
     ClassElement xElement = x.element;
     ClassElement yElement = y.element;
-    Set<ClassElement> subclasses = compiler.world.subclasses[yElement];
-    return (subclasses != null) ? subclasses.contains(xElement) : false;
+    // TODO(kasperl): Fix the discrepancy between subclass/subtype
+    // that occurs because of "unseen" classes.
+    return isSubtypeOf(x, y, compiler) && xElement.isSubclassOf(yElement);
   }
 
+  // TODO(kasperl): Move this to the world.
   static bool isSubtypeOf(DartType x, DartType y, Compiler compiler) {
     // TODO(kasperl): Do this error handling earlier.
     if (x.kind != TypeKind.INTERFACE) return false;