Revert "Implement subclass union and intersection on type mask."

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 04808bd72711e84ed942843ab4966a1dcfbeb221..5d4720d0f064123a5cd4290f036e5cfba82061a1 100644
--- a/sdk/lib/_internal/compiler/implementation/types/type_mask.dart
+++ b/sdk/lib/_internal/compiler/implementation/types/type_mask.dart
@@ -59,13 +59,20 @@ class TypeMask {
    * Returns whether or not this type mask contains the given type.
    */
   bool contains(DartType type, Compiler compiler) {
+    // TODO(kasperl): Do this error handling earlier.
+    if (base.kind != TypeKind.INTERFACE) return false;
+    assert(type.kind == TypeKind.INTERFACE);
+    // Compare the interface types.
+    ClassElement baseElement = base.element;
+    ClassElement typeElement = type.element;
     if (isExact) {
-      return identical(base.element, type.element);
+      return identical(baseElement, typeElement);
     } else if (isSubclass) {
-      return isSubclassOf(type, base, compiler);
+      return typeElement.isSubclassOf(baseElement);
     } else {
       assert(isSubtype);
-      return isSubtypeOf(type, base, compiler);
+      Set<ClassElement> subtypes = compiler.world.subtypes[baseElement];
+      return subtypes != null ? subtypes.contains(typeElement) : false;
     }
   }
 
@@ -81,22 +88,22 @@ class TypeMask {
         || identical(baseElement, compiler.dynamicClass);
   }
 
-  TypeMask union(TypeMask other, Compiler compiler) {
+  // TODO(kasperl): This implementation is a bit sketchy, but it
+  // behaves the same as the old implementation on HType. The plan is
+  // to extend this and add proper testing of it.
+  TypeMask union(TypeMask other, Types types) {
+    // TODO(kasperl): Add subclass handling.
     if (base == other.base) {
-      return unionSame(other, compiler);
-    } else if (isSubclassOf(other.base, base, compiler)) {
-      return unionSubclass(other, compiler);
-    } else if (isSubclassOf(base, other.base, compiler)) {
-      return other.unionSubclass(this, compiler);
-    } else if (isSubtypeOf(other.base, base, compiler)) {
-      return unionSubtype(other, compiler);
-    } else if (isSubtypeOf(base, other.base, compiler)) {
-      return other.unionSubtype(this, compiler);
+      return unionSame(other, types);
+    } else if (types.isSubtype(other.base, base)) {
+      return unionSubtype(other, types);
+    } else if (types.isSubtype(base, other.base)) {
+      return other.unionSubtype(this, types);
     }
     return null;
   }
 
-  TypeMask unionSame(TypeMask other, Compiler compiler) {
+  TypeMask unionSame(TypeMask other, Types types) {
     assert(base == other.base);
     // The two masks share the base type, so we must chose the least
     // constraining kind (the highest) of the two. If either one of
@@ -113,29 +120,8 @@ class TypeMask {
     }
   }
 
-  TypeMask unionSubclass(TypeMask other, Compiler compiler) {
-    assert(isSubclassOf(other.base, base, compiler));
-    int combined;
-    if (isExact && other.isExact) {
-      // Since the other mask is a subclass of this mask, we need the
-      // resulting union to be a subclass too. If either one of the
-      // masks are nullable the result should be nullable too.
-      combined = (SUBCLASS << 1) | ((flags | other.flags) & 1);
-    } else {
-      // Both masks are at least subclass masks, so we pick the least
-      // constraining kind (the highest) of the two. If either one of
-      // the masks are nullable the result should be nullable too.
-      combined = (flags > other.flags)
-          ? flags | (other.flags & 1)
-          : other.flags | (flags & 1);
-    }
-    return (flags != combined)
-        ? new TypeMask.internal(base, combined)
-        : this;
-  }
-
-  TypeMask unionSubtype(TypeMask other, Compiler compiler) {
-    assert(isSubtypeOf(other.base, base, compiler));
+  TypeMask unionSubtype(TypeMask other, Types types) {
+    assert(types.isSubtype(other.base, base));
     // Since the other mask is a subtype of this mask, we need the
     // resulting union to be a subtype too. If either one of the masks
     // are nullable the result should be nullable too.
@@ -145,68 +131,35 @@ class TypeMask {
         : this;
   }
 
-  TypeMask intersection(TypeMask other, Compiler compiler) {
-    if (base == other.base) {
-      return intersectionSame(other, compiler);
-    } else if (isSubclassOf(other.base, base, compiler)) {
-      return intersectionSubclass(other, compiler);
-    } else if (isSubclassOf(base, other.base, compiler)) {
-      return other.intersectionSubclass(this, compiler);
-    } else if (isSubtypeOf(other.base, base, compiler)) {
-      return intersectionSubtype(other, compiler);
-    } else if (isSubtypeOf(base, other.base, compiler)) {
-      return other.intersectionSubtype(this, compiler);
-    }
-    return null;
-  }
-
-  TypeMask intersectionSame(TypeMask other, Compiler compiler) {
-    assert(base == other.base);
-    // The two masks share the base type, so we must chose the most
-    // constraining kind (the lowest) of the two. Only if both masks
-    // are nullable, will the result be nullable too.
+  // TODO(kasperl): This implementation is a bit sketchy, but it
+  // behaves the same as the old implementation on HType. The plan is
+  // to extend this and add proper testing of it.
+  TypeMask intersection(TypeMask other, Types types) {
     int combined = (flags < other.flags)
         ? flags & ((other.flags & 1) | ~1)
         : other.flags & ((flags & 1) | ~1);
-    if (flags == combined) {
-      return this;
-    } else if (other.flags == combined) {
-      return other;
-    } else {
-      return new TypeMask.internal(base, combined);
-    }
-  }
-
-  TypeMask intersectionSubclass(TypeMask other, Compiler compiler) {
-    assert(isSubclassOf(other.base, base, compiler));
-    // If this mask isn't at least a subclass mask, then the
-    // intersection with the other mask is empty.
-    if (isExact) return null;
-    // Only the other mask puts constraints on the intersection mask,
-    // so base the combined flags on the other mask. Only if both
-    // masks are nullable, will the result be nullable too.
-    int combined = other.flags & ((flags & 1) | ~1);
-    if (other.flags == combined) {
-      return other;
-    } else {
-      return new TypeMask.internal(other.base, combined);
-    }
-  }
-
-  TypeMask intersectionSubtype(TypeMask other, Compiler compiler) {
-    assert(isSubtypeOf(other.base, base, compiler));
-    // If this mask isn't a subtype mask, then the intersection with
-    // the other mask is empty.
-    if (!isSubtype) return null;
-    // Only the other mask puts constraints on the intersection mask,
-    // so base the combined flags on the other mask. Only if both
-    // masks are nullable, will the result be nullable too.
-    int combined = other.flags & ((flags & 1) | ~1);
-    if (other.flags == combined) {
-      return other;
-    } else {
-      return new TypeMask.internal(other.base, combined);
+    if (base == other.base) {
+      if (flags == combined) {
+        return this;
+      } else if (other.flags == combined) {
+        return other;
+      } else {
+        return new TypeMask.internal(base, combined);
+      }
+    } else if (types.isSubtype(other.base, base)) {
+      if (other.flags == combined) {
+        return other;
+      } else {
+        return new TypeMask.internal(other.base, combined);
+      }
+    } else if (types.isSubtype(base, other.base)) {
+      if (flags == combined) {
+        return this;
+      } else {
+        return new TypeMask.internal(base, combined);
+      }
     }
+    return null;
   }
 
   bool operator ==(var other) {
@@ -224,27 +177,4 @@ class TypeMask {
     buffer.write(base.element.name.slowToString());
     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;
-    // TODO(kasperl): Fix the discrepancy between subclass/subtype
-    // that occurs because of "unseen" classes.
-    return isSubtypeOf(x, y, compiler) && yElement.isSubclassOf(xElement);
-  }
-
-  // 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;
-    if (y.kind != TypeKind.INTERFACE) return false;
-    ClassElement xElement = x.element;
-    ClassElement yElement = y.element;
-    Set<ClassElement> subtypes = compiler.world.subtypes[yElement];
-    return (subtypes != null) ? subtypes.contains(xElement) : false;
-  }
 }