Refactor HType to get rid of various hacks.

test/cctest/test-hydrogen-types.cc

Index: test/cctest/test-hydrogen-types.cc
diff --git a/test/cctest/test-hydrogen-types.cc b/test/cctest/test-hydrogen-types.cc
new file mode 100644
index 0000000000000000000000000000000000000000..1d333c6c2683ba20ba421e50d67843e57ec7fa93
--- /dev/null
+++ b/test/cctest/test-hydrogen-types.cc
@@ -0,0 +1,168 @@
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "hydrogen-types.h"
+
+#include "cctest.h"
+
+using namespace v8::internal;
+
+
+static const HType kTypes[] = {
+  #define DECLARE_TYPE(Name, mask) HType::Name(),
+  HTYPE_LIST(DECLARE_TYPE)
+  #undef DECLARE_TYPE
+};
+
+static const int kNumberOfTypes = sizeof(kTypes) / sizeof(kTypes[0]);
+
+
+TEST(HTypeDistinct) {
+  for (int i = 0; i < kNumberOfTypes; ++i) {
+    for (int j = 0; j < kNumberOfTypes; ++j) {
+      CHECK(i == j || !kTypes[i].Equals(kTypes[j]));
+    }
+  }
+}
+
+
+TEST(HTypeReflexivity) {
+  // Reflexivity of =
+  for (int i = 0; i < kNumberOfTypes; ++i) {
+    CHECK(kTypes[i].Equals(kTypes[i]));
+  }
+
+  // Reflexivity of <
+  for (int i = 0; i < kNumberOfTypes; ++i) {
+    CHECK(kTypes[i].IsSubtypeOf(kTypes[i]));
+  }
+}
+
+
+TEST(HTypeTransitivity) {
+  // Transitivity of =
+  for (int i = 0; i < kNumberOfTypes; ++i) {
+    for (int j = 0; j < kNumberOfTypes; ++j) {
+      for (int k = 0; k < kNumberOfTypes; ++k) {
+        HType ti = kTypes[i];
+        HType tj = kTypes[j];
+        HType tk = kTypes[k];
+        CHECK(!ti.Equals(tj) || !tj.Equals(tk) || ti.Equals(tk));
+      }
+    }
+  }
+
+  // Transitivity of <
+  for (int i = 0; i < kNumberOfTypes; ++i) {
+    for (int j = 0; j < kNumberOfTypes; ++j) {
+      for (int k = 0; k < kNumberOfTypes; ++k) {
+        HType ti = kTypes[i];
+        HType tj = kTypes[j];
+        HType tk = kTypes[k];
+        CHECK(!ti.IsSubtypeOf(tj) || !tj.IsSubtypeOf(tk) || ti.IsSubtypeOf(tk));
+      }
+    }
+  }
+}
+
+
+TEST(HTypeCombine) {
+  // T < T /\ T' and T' < T /\ T' for all T,T'
+  for (int i = 0; i < kNumberOfTypes; ++i) {
+    for (int j = 0; j < kNumberOfTypes; ++j) {
+      HType ti = kTypes[i];
+      HType tj = kTypes[j];
+      CHECK(ti.IsSubtypeOf(ti.Combine(tj)));
+      CHECK(tj.IsSubtypeOf(ti.Combine(tj)));
+    }
+  }
+}
+
+
+TEST(HTypeAny) {
+  // T < Any for all T
+  for (int i = 0; i < kNumberOfTypes; ++i) {
+    HType ti = kTypes[i];
+    CHECK(ti.IsAny());
+  }
+
+  // Any < T implies T = Any for all T
+  for (int i = 0; i < kNumberOfTypes; ++i) {
+    HType ti = kTypes[i];
+    CHECK(!HType::Any().IsSubtypeOf(ti) || HType::Any().Equals(ti));
+  }
+}
+
+
+TEST(HTypeTagged) {
+  // T < Tagged for all T \ {Any}
+  for (int i = 0; i < kNumberOfTypes; ++i) {
+    HType ti = kTypes[i];
+    CHECK(ti.IsTagged() || HType::Any().Equals(ti));
+  }
+
+  // Tagged < T implies T = Tagged or T = Any
+  for (int i = 0; i < kNumberOfTypes; ++i) {
+    HType ti = kTypes[i];
+    CHECK(!HType::Tagged().IsSubtypeOf(ti) ||
+          HType::Tagged().Equals(ti) ||
+          HType::Any().Equals(ti));
+  }
+}
+
+
+TEST(HTypeSmi) {
+  // T < Smi implies T = None or T = Smi for all T
+  for (int i = 0; i < kNumberOfTypes; ++i) {
+    HType ti = kTypes[i];
+    CHECK(!ti.IsSmi() ||
+          ti.Equals(HType::Smi()) ||
+          ti.Equals(HType::None()));
+  }
+}
+
+
+TEST(HTypeHeapObject) {
+  CHECK(!HType::TaggedPrimitive().IsHeapObject());
+  CHECK(!HType::TaggedNumber().IsHeapObject());
+  CHECK(!HType::Smi().IsHeapObject());
+  CHECK(HType::HeapObject().IsHeapObject());
+  CHECK(HType::HeapPrimitive().IsHeapObject());
+  CHECK(HType::Null().IsHeapObject());
+  CHECK(HType::HeapNumber().IsHeapObject());
+  CHECK(HType::String().IsHeapObject());
+  CHECK(HType::Boolean().IsHeapObject());
+  CHECK(HType::Undefined().IsHeapObject());
+  CHECK(HType::JSObject().IsHeapObject());
+  CHECK(HType::JSArray().IsHeapObject());
+}
+
+
+TEST(HTypePrimitive) {
+  CHECK(HType::TaggedNumber().IsTaggedPrimitive());
+  CHECK(HType::Smi().IsTaggedPrimitive());
+  CHECK(!HType::HeapObject().IsTaggedPrimitive());
+  CHECK(HType::HeapPrimitive().IsTaggedPrimitive());
+  CHECK(HType::Null().IsHeapPrimitive());
+  CHECK(HType::HeapNumber().IsHeapPrimitive());
+  CHECK(HType::String().IsHeapPrimitive());
+  CHECK(HType::Boolean().IsHeapPrimitive());
+  CHECK(HType::Undefined().IsHeapPrimitive());
+  CHECK(!HType::JSObject().IsTaggedPrimitive());
+  CHECK(!HType::JSArray().IsTaggedPrimitive());
+}
+
+
+TEST(HTypeJSObject) {
+  CHECK(HType::JSArray().IsJSObject());
+}
+
+
+TEST(HTypeNone) {
+  // None < T for all T
+  for (int i = 0; i < kNumberOfTypes; ++i) {
+    HType ti = kTypes[i];
+    CHECK(HType::None().IsSubtypeOf(ti));
+  }
+}