From: rossberg@chromium.org Date: Mon, 14 Apr 2014 09:46:56 +0000 (+0000) Subject: Revert "Reland "More tests for Union & Intersect"" X-Git-Tag: upstream/4.7.83~9653 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=b73257b7a34758de49d398c9e3cf65b4cd5ce95b;p=platform%2Fupstream%2Fv8.git Revert "Reland "More tests for Union & Intersect"" Need to reproduce wrong result only occurring with ASAN. TBR=jarin@chromium.org BUG= Review URL: https://codereview.chromium.org/236873002 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20712 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- diff --git a/src/types.cc b/src/types.cc index 4ddc14b..4526b6f 100644 --- a/src/types.cc +++ b/src/types.cc @@ -306,9 +306,6 @@ bool TypeImpl::SlowIs(TypeImpl* that) { template bool TypeImpl::NowIs(TypeImpl* that) { - // TODO(rossberg): this is incorrect for - // Union(Constant(V), T)->NowIs(Class(M)) - // but fuzzing does not cover that! DisallowHeapAllocation no_allocation; if (this->IsConstant()) { i::Object* object = *this->AsConstant(); @@ -438,12 +435,12 @@ typename TypeImpl::TypeHandle TypeImpl::Union( size += (type2->IsUnion() ? Config::struct_length(type2->AsUnion()) : 1); } int bitset = type1->GlbBitset() | type2->GlbBitset(); - if (bitset != kNone) ++size; + if (IsInhabited(bitset)) ++size; ASSERT(size >= 1); StructHandle unioned = Config::struct_create(kUnionTag, size, region); size = 0; - if (bitset != kNone) { + if (IsInhabited(bitset)) { Config::struct_set(unioned, size++, Config::from_bitset(bitset, region)); } size = ExtendUnion(unioned, type1, size); @@ -505,20 +502,21 @@ typename TypeImpl::TypeHandle TypeImpl::Intersect( } // Slow case: may need to produce a Unioned object. - int size = 0; + int size = INT_MAX; if (!type1->IsBitset()) { - size += (type1->IsUnion() ? Config::struct_length(type1->AsUnion()) : 1); + size = (type1->IsUnion() ? Config::struct_length(type1->AsUnion()) : 1); } if (!type2->IsBitset()) { - size += (type2->IsUnion() ? Config::struct_length(type2->AsUnion()) : 1); + size = Min(size, + type2->IsUnion() ? Config::struct_length(type2->AsUnion()) : 1); } int bitset = type1->GlbBitset() & type2->GlbBitset(); - if (bitset != kNone) ++size; + if (IsInhabited(bitset)) ++size; ASSERT(size >= 1); StructHandle unioned = Config::struct_create(kUnionTag, size, region); size = 0; - if (bitset != kNone) { + if (IsInhabited(bitset)) { Config::struct_set(unioned, size++, Config::from_bitset(bitset, region)); } size = ExtendIntersection(unioned, type1, type2, size); diff --git a/src/types.h b/src/types.h index 3a3bc3b..da63e5f 100644 --- a/src/types.h +++ b/src/types.h @@ -101,11 +101,11 @@ namespace internal { // PROPERTIES // // Various formal properties hold for constructors, operators, and predicates -// over types. For example, constructors are injective, subtyping is a complete -// partial order, union and intersection satisfy the usual algebraic properties. +// over types. For example, constructors are injective, subtyping is a partial +// order, and union and intersection satisfy the usual algebraic properties. // // See test/cctest/test-types.cc for a comprehensive executable specification, -// especially with respect to the properties of the more exotic 'temporal' +// especially with respect to the proeprties of the more exotic 'temporal' // constructors and predicates (those prefixed 'Now'). // // IMPLEMENTATION diff --git a/test/cctest/test-types.cc b/test/cctest/test-types.cc index ea7c73e..1526b84 100644 --- a/test/cctest/test-types.cc +++ b/test/cctest/test-types.cc @@ -33,69 +33,13 @@ using namespace v8::internal; -// Testing auxiliaries (breaking the Type abstraction). -struct ZoneRep { - typedef void* Struct; - - static bool IsStruct(Type* t, int tag) { - return !IsBitset(t) && reinterpret_cast(AsStruct(t)[0]) == tag; - } - static bool IsBitset(Type* t) { return reinterpret_cast(t) & 1; } - static bool IsClass(Type* t) { return IsStruct(t, 0); } - static bool IsConstant(Type* t) { return IsStruct(t, 1); } - static bool IsUnion(Type* t) { return IsStruct(t, 2); } - - static Struct* AsStruct(Type* t) { - return reinterpret_cast(t); - } - static int AsBitset(Type* t) { - return static_cast(reinterpret_cast(t) >> 1); - } - static Map* AsClass(Type* t) { - return *static_cast(AsStruct(t)[3]); - } - static Object* AsConstant(Type* t) { - return *static_cast(AsStruct(t)[3]); - } - static Struct* AsUnion(Type* t) { - return AsStruct(t); - } - static int Length(Struct* structured) { - return static_cast(reinterpret_cast(structured[1])); - } - - static Zone* ToRegion(Zone* zone, Isolate* isolate) { return zone; } -}; - - -struct HeapRep { - typedef FixedArray Struct; - - static bool IsStruct(Handle t, int tag) { - return t->IsFixedArray() && Smi::cast(AsStruct(t)->get(0))->value() == tag; - } - static bool IsBitset(Handle t) { return t->IsSmi(); } - static bool IsClass(Handle t) { return t->IsMap(); } - static bool IsConstant(Handle t) { return t->IsBox(); } - static bool IsUnion(Handle t) { return IsStruct(t, 2); } - - static Struct* AsStruct(Handle t) { return FixedArray::cast(*t); } - static int AsBitset(Handle t) { return Smi::cast(*t)->value(); } - static Map* AsClass(Handle t) { return Map::cast(*t); } - static Object* AsConstant(Handle t) { - return Box::cast(*t)->value(); - } - static Struct* AsUnion(Handle t) { return AsStruct(t); } - static int Length(Struct* structured) { return structured->length() - 1; } - - static Isolate* ToRegion(Zone* zone, Isolate* isolate) { return isolate; } -}; - - template class Types { public: Types(Region* region, Isolate* isolate) : region_(region) { + static const size_t kMaxTypes = 300; + types.reserve(kMaxTypes); + #define DECLARE_TYPE(name, value) \ name = Type::name(region); \ types.push_back(name); @@ -139,11 +83,15 @@ class Types { types.push_back(Type::Constant(*it, region)); } - for (int i = 0; i < 100; ++i) { - types.push_back(Fuzz()); + while (types.size() < kMaxTypes) { + size_t i = rng.NextInt(static_cast(types.size())); + size_t j = rng.NextInt(static_cast(types.size())); + if (i != j) types.push_back(Type::Union(types[i], types[j], region)); } } + RandomNumberGenerator rng; + #define DECLARE_TYPE(name, value) TypeHandle name; BITSET_TYPE_LIST(DECLARE_TYPE) #undef DECLARE_TYPE @@ -205,44 +153,67 @@ class Types { return Type::template Convert(t, region_); } - TypeHandle Fuzz(int depth = 5) { - switch (rng_.NextInt(depth == 0 ? 3 : 20)) { - case 0: { // bitset - int n = 0 - #define COUNT_BITSET_TYPES(type, value) + 1 - BITSET_TYPE_LIST(COUNT_BITSET_TYPES) - #undef COUNT_BITSET_TYPES - ; - int i = rng_.NextInt(n); - #define PICK_BITSET_TYPE(type, value) \ - if (i-- == 0) return Type::type(region_); - BITSET_TYPE_LIST(PICK_BITSET_TYPE) - #undef PICK_BITSET_TYPE - UNREACHABLE(); - } - case 1: { // class - int i = rng_.NextInt(static_cast(maps.size())); - return Type::Class(maps[i], region_); - } - case 2: { // constant - int i = rng_.NextInt(static_cast(values.size())); - return Type::Constant(values[i], region_); - } - default: { // union - int n = rng_.NextInt(10); - TypeHandle type = None; - for (int i = 0; i < n; ++i) { - type = Type::Union(type, Fuzz(depth - 1), region_); - } - return type; - } - } - UNREACHABLE(); - } - private: Region* region_; - RandomNumberGenerator rng_; +}; + + +// Testing auxiliaries (breaking the Type abstraction). +struct ZoneRep { + typedef void* Struct; + + static bool IsStruct(Type* t, int tag) { + return !IsBitset(t) && reinterpret_cast(AsStruct(t)[0]) == tag; + } + static bool IsBitset(Type* t) { return reinterpret_cast(t) & 1; } + static bool IsClass(Type* t) { return IsStruct(t, 0); } + static bool IsConstant(Type* t) { return IsStruct(t, 1); } + static bool IsUnion(Type* t) { return IsStruct(t, 2); } + + static Struct* AsStruct(Type* t) { + return reinterpret_cast(t); + } + static int AsBitset(Type* t) { + return static_cast(reinterpret_cast(t) >> 1); + } + static Map* AsClass(Type* t) { + return *static_cast(AsStruct(t)[3]); + } + static Object* AsConstant(Type* t) { + return *static_cast(AsStruct(t)[3]); + } + static Struct* AsUnion(Type* t) { + return AsStruct(t); + } + static int Length(Struct* structured) { + return static_cast(reinterpret_cast(structured[1])); + } + + static Zone* ToRegion(Zone* zone, Isolate* isolate) { return zone; } +}; + + +struct HeapRep { + typedef FixedArray Struct; + + static bool IsStruct(Handle t, int tag) { + return t->IsFixedArray() && Smi::cast(AsStruct(t)->get(0))->value() == tag; + } + static bool IsBitset(Handle t) { return t->IsSmi(); } + static bool IsClass(Handle t) { return t->IsMap(); } + static bool IsConstant(Handle t) { return t->IsBox(); } + static bool IsUnion(Handle t) { return IsStruct(t, 2); } + + static Struct* AsStruct(Handle t) { return FixedArray::cast(*t); } + static int AsBitset(Handle t) { return Smi::cast(*t)->value(); } + static Map* AsClass(Handle t) { return Map::cast(*t); } + static Object* AsConstant(Handle t) { + return Box::cast(*t)->value(); + } + static Struct* AsUnion(Handle t) { return AsStruct(t); } + static int Length(Struct* structured) { return structured->length() - 1; } + + static Isolate* ToRegion(Zone* zone, Isolate* isolate) { return isolate; } }; @@ -265,27 +236,25 @@ struct Tests : Rep { T(Rep::ToRegion(&zone, isolate), isolate) { } - bool Equal(TypeHandle type1, TypeHandle type2) { - return - type1->Is(type2) && type2->Is(type1) && - Rep::IsBitset(type1) == Rep::IsBitset(type2) && - Rep::IsClass(type1) == Rep::IsClass(type2) && - Rep::IsConstant(type1) == Rep::IsConstant(type2) && - Rep::IsUnion(type1) == Rep::IsUnion(type2) && - type1->NumClasses() == type2->NumClasses() && - type1->NumConstants() == type2->NumConstants() && - (!Rep::IsBitset(type1) || - Rep::AsBitset(type1) == Rep::AsBitset(type2)) && - (!Rep::IsClass(type1) || - Rep::AsClass(type1) == Rep::AsClass(type2)) && - (!Rep::IsConstant(type1) || - Rep::AsConstant(type1) == Rep::AsConstant(type2)) && - (!Rep::IsUnion(type1) || - Rep::Length(Rep::AsUnion(type1)) == Rep::Length(Rep::AsUnion(type2))); - } - void CheckEqual(TypeHandle type1, TypeHandle type2) { - CHECK(Equal(type1, type2)); + CHECK_EQ(Rep::IsBitset(type1), Rep::IsBitset(type2)); + CHECK_EQ(Rep::IsClass(type1), Rep::IsClass(type2)); + CHECK_EQ(Rep::IsConstant(type1), Rep::IsConstant(type2)); + CHECK_EQ(Rep::IsUnion(type1), Rep::IsUnion(type2)); + CHECK_EQ(type1->NumClasses(), type2->NumClasses()); + CHECK_EQ(type1->NumConstants(), type2->NumConstants()); + if (Rep::IsBitset(type1)) { + CHECK_EQ(Rep::AsBitset(type1), Rep::AsBitset(type2)); + } else if (Rep::IsClass(type1)) { + CHECK_EQ(Rep::AsClass(type1), Rep::AsClass(type2)); + } else if (Rep::IsConstant(type1)) { + CHECK_EQ(Rep::AsConstant(type1), Rep::AsConstant(type2)); + } else if (Rep::IsUnion(type1)) { + CHECK_EQ( + Rep::Length(Rep::AsUnion(type1)), Rep::Length(Rep::AsUnion(type2))); + } + CHECK(type1->Is(type2)); + CHECK(type2->Is(type1)); } void CheckSub(TypeHandle type1, TypeHandle type2) { @@ -332,7 +301,7 @@ struct Tests : Rep { CHECK_EQ(0, this->AsBitset(T.None)); CHECK_EQ(-1, this->AsBitset(T.Any)); - // Union(T1, T2) is bitset for bitsets T1,T2 + // Union(T1, T2) is a bitset for all bitsets T1,T2 for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { TypeHandle type1 = *it1; @@ -342,17 +311,20 @@ struct Tests : Rep { } } - // Union(T1, T2) is bitset if T2 is bitset and T1->Is(T2) + // Union(T1, T2) is a bitset if T2 is a bitset and T1->Is(T2) + // (and vice versa). for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { TypeHandle type1 = *it1; TypeHandle type2 = *it2; CHECK(!(this->IsBitset(type2) && type1->Is(type2)) || this->IsBitset(T.Union(type1, type2))); + CHECK(!(this->IsBitset(type1) && type2->Is(type1)) || + this->IsBitset(T.Union(type1, type2))); } } - // Union(T1, T2) is bitwise disjunction for bitsets T1,T2 + // Union(T1, T2) is bitwise disjunction for all bitsets T1,T2 for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { TypeHandle type1 = *it1; @@ -365,7 +337,7 @@ struct Tests : Rep { } } - // Intersect(T1, T2) is bitwise conjunction for bitsets T1,T2 + // Intersect(T1, T2) is bitwise conjunction for all bitsets T1,T2 for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { TypeHandle type1 = *it1; @@ -392,12 +364,12 @@ struct Tests : Rep { CHECK(*map == *T.Class(map)->AsClass()); } - // Functionality & Injectivity: Class(M1) = Class(M2) iff M1 = M2 + // Functionality & Injectivity for (MapIterator mt1 = T.maps.begin(); mt1 != T.maps.end(); ++mt1) { for (MapIterator mt2 = T.maps.begin(); mt2 != T.maps.end(); ++mt2) { Handle map1 = *mt1; Handle map2 = *mt2; - CHECK(Equal(T.Class(map1), T.Class(map2)) == (*map1 == *map2)); + CHECK(T.Class(map1)->Is(T.Class(map2)) == (*map1 == *map2)); } } } @@ -415,100 +387,100 @@ struct Tests : Rep { CHECK(*value == *T.Constant(value)->AsConstant()); } - // Functionality & Injectivity: Constant(V1) = Constant(v2) iff V1 = V2 + // Functionality & Injectivity for (ValueIterator vt1 = T.values.begin(); vt1 != T.values.end(); ++vt1) { for (ValueIterator vt2 = T.values.begin(); vt2 != T.values.end(); ++vt2) { Handle val1 = *vt1; Handle val2 = *vt2; - CHECK(Equal(T.Constant(val1), T.Constant(val2)) == (*val1 == *val2)); + CHECK(T.Constant(val1)->Is(T.Constant(val2)) == (*val1 == *val2)); } } } void Of() { - // Constant(V)->Is(Of(V)) + // Constant(V)->Is(Of(V)) for all V for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) { Handle value = *vt; CHECK(T.Constant(value)->Is(T.Of(value))); } - // Constant(V)->Is(T) iff Of(V)->Is(T) or T->Maybe(Constant(V)) + // Constant(V)->Is(T) implies Of(V)->Is(T) or T->Maybe(Constant(V)) for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) { for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { Handle value = *vt; TypeHandle type = *it; - CHECK(T.Constant(value)->Is(type) == - (T.Of(value)->Is(type) || type->Maybe(T.Constant(value)))); + CHECK(!T.Constant(value)->Is(type) || + T.Of(value)->Is(type) || type->Maybe(T.Constant(value))); } } } void NowOf() { - // Constant(V)->NowIs(NowOf(V)) + // Constant(V)->NowIs(NowOf(V)) for all V for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) { Handle value = *vt; CHECK(T.Constant(value)->NowIs(T.NowOf(value))); } - // NowOf(V)->Is(Of(V)) + // NowOf(V)->Is(Of(V)) for all V for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) { Handle value = *vt; CHECK(T.NowOf(value)->Is(T.Of(value))); } - // Constant(V)->NowIs(T) iff NowOf(V)->NowIs(T) or T->Maybe(Constant(V)) + // Constant(V)->Is(T) implies NowOf(V)->Is(T) or T->Maybe(Constant(V)) for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) { for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { Handle value = *vt; TypeHandle type = *it; - CHECK(T.Constant(value)->NowIs(type) == - (T.NowOf(value)->NowIs(type) || type->Maybe(T.Constant(value)))); + CHECK(!T.Constant(value)->Is(type) || + T.NowOf(value)->Is(type) || type->Maybe(T.Constant(value))); } } - // Constant(V)->Is(T) implies NowOf(V)->Is(T) or T->Maybe(Constant(V)) + // Constant(V)->NowIs(T) implies NowOf(V)->NowIs(T) or T->Maybe(Constant(V)) for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) { for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { Handle value = *vt; TypeHandle type = *it; - CHECK(!T.Constant(value)->Is(type) || - (T.NowOf(value)->Is(type) || type->Maybe(T.Constant(value)))); + CHECK(!T.Constant(value)->NowIs(type) || + T.NowOf(value)->NowIs(type) || type->Maybe(T.Constant(value))); } } } void Is() { - // Least Element (Bottom): None->Is(T) + // T->Is(None) implies T = None for all T for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { TypeHandle type = *it; - CHECK(T.None->Is(type)); + if (type->Is(T.None)) CheckEqual(type, T.None); } - // Greatest Element (Top): T->Is(Any) + // None->Is(T) for all T for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { TypeHandle type = *it; - CHECK(type->Is(T.Any)); + CHECK(T.None->Is(type)); } - // Bottom Uniqueness: T->Is(None) implies T = None + // Any->Is(T) implies T = Any for all T for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { TypeHandle type = *it; - if (type->Is(T.None)) CheckEqual(type, T.None); + if (T.Any->Is(type)) CheckEqual(type, T.Any); } - // Top Uniqueness: Any->Is(T) implies T = Any + // T->Is(Any) for all T for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { TypeHandle type = *it; - if (T.Any->Is(type)) CheckEqual(type, T.Any); + CHECK(type->Is(T.Any)); } - // Reflexivity: T->Is(T) + // Reflexivity for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { TypeHandle type = *it; CHECK(type->Is(type)); } - // Transitivity: T1->Is(T2) and T2->Is(T3) implies T1->Is(T3) + // Transitivity for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { for (TypeIterator it3 = T.types.begin(); it3 != T.types.end(); ++it3) { @@ -520,15 +492,6 @@ struct Tests : Rep { } } - // Antisymmetry: T1->Is(T2) and T2->Is(T1) iff T1 = T2 - for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { - for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { - TypeHandle type1 = *it1; - TypeHandle type2 = *it2; - CHECK((type1->Is(type2) && type2->Is(type1)) == Equal(type1, type2)); - } - } - // Constant(V1)->Is(Constant(V2)) iff V1 = V2 for (ValueIterator vt1 = T.values.begin(); vt1 != T.values.end(); ++vt1) { for (ValueIterator vt2 = T.values.begin(); vt2 != T.values.end(); ++vt2) { @@ -547,7 +510,7 @@ struct Tests : Rep { } } - // Constant(V)->Is(Class(M)) never + // Constant(V)->Is(Class(M)) for no V,M for (MapIterator mt = T.maps.begin(); mt != T.maps.end(); ++mt) { for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) { Handle map = *mt; @@ -556,7 +519,7 @@ struct Tests : Rep { } } - // Class(M)->Is(Constant(V)) never + // Class(M)->Is(Constant(V)) for no V,M for (MapIterator mt = T.maps.begin(); mt != T.maps.end(); ++mt) { for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) { Handle map = *mt; @@ -595,13 +558,17 @@ struct Tests : Rep { CheckUnordered(T.Object, T.Proxy); CheckUnordered(T.Array, T.Function); + CheckSub(T.UninitializedClass, T.Internal); + CheckSub(T.UninitializedConstant, T.Internal); + CheckUnordered(T.UninitializedClass, T.Null); + CheckUnordered(T.UninitializedClass, T.Undefined); + CheckUnordered(T.UninitializedConstant, T.Null); + CheckUnordered(T.UninitializedConstant, T.Undefined); + // Structural types CheckSub(T.ObjectClass, T.Object); CheckSub(T.ArrayClass, T.Object); - CheckSub(T.UninitializedClass, T.Internal); CheckUnordered(T.ObjectClass, T.ArrayClass); - CheckUnordered(T.UninitializedClass, T.Null); - CheckUnordered(T.UninitializedClass, T.Undefined); CheckSub(T.SmiConstant, T.SignedSmall); CheckSub(T.SmiConstant, T.Signed32); @@ -610,11 +577,8 @@ struct Tests : Rep { CheckSub(T.ObjectConstant2, T.Object); CheckSub(T.ArrayConstant, T.Object); CheckSub(T.ArrayConstant, T.Array); - CheckSub(T.UninitializedConstant, T.Internal); CheckUnordered(T.ObjectConstant1, T.ObjectConstant2); CheckUnordered(T.ObjectConstant1, T.ArrayConstant); - CheckUnordered(T.UninitializedConstant, T.Null); - CheckUnordered(T.UninitializedConstant, T.Undefined); CheckUnordered(T.ObjectConstant1, T.ObjectClass); CheckUnordered(T.ObjectConstant2, T.ObjectClass); @@ -624,60 +588,51 @@ struct Tests : Rep { } void NowIs() { - // Least Element (Bottom): None->NowIs(T) + // T->NowIs(None) implies T = None for all T for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { TypeHandle type = *it; - CHECK(T.None->NowIs(type)); + if (type->NowIs(T.None)) CheckEqual(type, T.None); } - // Greatest Element (Top): T->NowIs(Any) + // None->NowIs(T) for all T for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { TypeHandle type = *it; - CHECK(type->NowIs(T.Any)); + CHECK(T.None->NowIs(type)); } - // Bottom Uniqueness: T->NowIs(None) implies T = None + // Any->NowIs(T) implies T = Any for all T for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { TypeHandle type = *it; - if (type->NowIs(T.None)) CheckEqual(type, T.None); + if (T.Any->NowIs(type)) CheckEqual(type, T.Any); } - // Top Uniqueness: Any->NowIs(T) implies T = Any + // T->NowIs(Any) for all T for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { TypeHandle type = *it; - if (T.Any->NowIs(type)) CheckEqual(type, T.Any); + CHECK(type->NowIs(T.Any)); } - // Reflexivity: T->NowIs(T) + // Reflexivity for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { TypeHandle type = *it; CHECK(type->NowIs(type)); } - // Transitivity: T1->NowIs(T2) and T2->NowIs(T3) implies T1->NowIs(T3) + // Transitivity for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { for (TypeIterator it3 = T.types.begin(); it3 != T.types.end(); ++it3) { TypeHandle type1 = *it1; TypeHandle type2 = *it2; TypeHandle type3 = *it3; - CHECK(!(type1->NowIs(type2) && type2->NowIs(type3)) || + CHECK(!type1->NowIs(type2) || + !type2->NowIs(type3) || type1->NowIs(type3)); } } } - // Antisymmetry: T1->NowIs(T2) and T2->NowIs(T1) iff T1 = T2 - for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { - for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { - TypeHandle type1 = *it1; - TypeHandle type2 = *it2; - CHECK((type1->NowIs(type2) && type2->NowIs(type1)) == - Equal(type1, type2)); - } - } - - // T1->Is(T2) implies T1->NowIs(T2) + // T1->Is(T2) implies T1->NowIs(T2) for all T1,T2 for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { TypeHandle type1 = *it1; @@ -715,7 +670,7 @@ struct Tests : Rep { } } - // Class(M)->NowIs(Constant(V)) never + // Class(M)->NowIs(Constant(V)) for no V,M for (MapIterator mt = T.maps.begin(); mt != T.maps.end(); ++mt) { for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) { Handle map = *mt; @@ -726,7 +681,7 @@ struct Tests : Rep { } void Contains() { - // T->Contains(V) iff Constant(V)->Is(T) + // T->Contains(V) iff Constant(V)->Is(T) for all T,V for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) { TypeHandle type = *it; @@ -735,7 +690,7 @@ struct Tests : Rep { } } - // Of(V)->Is(T) implies T->Contains(V) + // Of(V)->Is(T) implies T->Contains(V) for all T,V for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) { TypeHandle type = *it; @@ -746,7 +701,7 @@ struct Tests : Rep { } void NowContains() { - // T->NowContains(V) iff Constant(V)->NowIs(T) + // T->NowContains(V) iff Constant(V)->NowIs(T) for all T,V for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) { TypeHandle type = *it; @@ -755,7 +710,7 @@ struct Tests : Rep { } } - // T->Contains(V) implies T->NowContains(V) + // T->Contains(V) implies T->NowContains(V) for all T,V for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) { TypeHandle type = *it; @@ -764,7 +719,7 @@ struct Tests : Rep { } } - // NowOf(V)->Is(T) implies T->NowContains(V) + // NowOf(V)->Is(T) implies T->NowContains(V) for all T,V for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) { TypeHandle type = *it; @@ -773,7 +728,7 @@ struct Tests : Rep { } } - // NowOf(V)->NowIs(T) implies T->NowContains(V) + // NowOf(V)->NowIs(T) implies T->NowContains(V) for all T,V for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) { TypeHandle type = *it; @@ -784,25 +739,25 @@ struct Tests : Rep { } void Maybe() { - // T->Maybe(Any) iff T inhabited + // T->Maybe(T) iff T inhabited for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { TypeHandle type = *it; - CHECK(type->Maybe(T.Any) == type->IsInhabited()); + CHECK(type->Maybe(type) == type->IsInhabited()); } - // T->Maybe(None) never + // T->Maybe(Any) iff T inhabited for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { TypeHandle type = *it; - CHECK(!type->Maybe(T.None)); + CHECK(type->Maybe(T.Any) == type->IsInhabited()); } - // Reflexivity upto Inhabitation: T->Maybe(T) iff T inhabited + // T->Maybe(None) never for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { TypeHandle type = *it; - CHECK(type->Maybe(type) == type->IsInhabited()); + CHECK(!type->Maybe(T.None)); } - // Symmetry: T1->Maybe(T2) iff T2->Maybe(T1) + // Symmetry for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { TypeHandle type1 = *it1; @@ -811,7 +766,7 @@ struct Tests : Rep { } } - // T1->Maybe(T2) implies T1, T2 inhabited + // T1->Maybe(T2) only if T1, T2 inhabited for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { TypeHandle type1 = *it1; @@ -821,16 +776,7 @@ struct Tests : Rep { } } - // T1->Maybe(T2) iff Intersect(T1, T2) inhabited - for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { - for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { - TypeHandle type1 = *it1; - TypeHandle type2 = *it2; - CHECK(type1->Maybe(type2) == T.Intersect(type1, type2)->IsInhabited()); - } - } - - // T1->Is(T2) and T1 inhabited implies T1->Maybe(T2) + // T1->Is(T2) and T1 inhabited implies T1->Maybe(T2) for all T1,T2 for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { TypeHandle type1 = *it1; @@ -858,7 +804,7 @@ struct Tests : Rep { } } - // Constant(V)->Maybe(Class(M)) never + // Constant(V)->Maybe(Class(M)) for no V,M for (MapIterator mt = T.maps.begin(); mt != T.maps.end(); ++mt) { for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) { Handle map = *mt; @@ -867,7 +813,7 @@ struct Tests : Rep { } } - // Class(M)->Maybe(Constant(V)) never + // Class(M)->Maybe(Constant(V)) for no V,M for (MapIterator mt = T.maps.begin(); mt != T.maps.end(); ++mt) { for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) { Handle map = *mt; @@ -930,124 +876,62 @@ struct Tests : Rep { } void Union() { - // Identity: Union(T, None) = T - for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { - TypeHandle type = *it; - CheckEqual(T.Union(type, T.None), type); - } - - // Domination: Union(T, Any) = Any - for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { - TypeHandle type = *it; - CheckEqual(T.Union(type, T.Any), T.Any); - } - - // Idempotence: Union(T, T) = T - for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { - TypeHandle type = *it; - CheckEqual(T.Union(type, type), type); - } - - // Commutativity: Union(T1, T2) = Union(T2, T1) - for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { - for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { - TypeHandle type1 = *it1; - TypeHandle type2 = *it2; - CheckEqual(T.Union(type1, type2), T.Union(type2, type1)); - } - } - - // Associativity: Union(T1, Union(T2, T3)) = Union(Union(T1, T2), T3) - for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { - for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { - for (TypeIterator it3 = T.types.begin(); it3 != T.types.end(); ++it3) { - TypeHandle type1 = *it1; - TypeHandle type2 = *it2; - TypeHandle type3 = *it3; - CheckEqual( - T.Union(type1, T.Union(type2, type3)), - T.Union(T.Union(type1, type2), type3)); - } - } - } - - // Meet: T1->Is(Union(T1, T2)) and T2->Is(Union(T1, T2)) - for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { - for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { - TypeHandle type1 = *it1; - TypeHandle type2 = *it2; - CHECK(type1->Is(T.Union(type1, type2))); - CHECK(type2->Is(T.Union(type1, type2))); - } - } - - // Upper Boundedness: T1->Is(T2) implies Union(T1, T2) = T2 - for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { - for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { - TypeHandle type1 = *it1; - TypeHandle type2 = *it2; - if (type1->Is(type2)) CheckEqual(T.Union(type1, type2), type2); - } - } - - // Monotonicity: T1->Is(T2) implies Union(T1, T3)->Is(Union(T2, T3)) - for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { - for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { - for (TypeIterator it3 = T.types.begin(); it3 != T.types.end(); ++it3) { - TypeHandle type1 = *it1; - TypeHandle type2 = *it2; - TypeHandle type3 = *it3; - CHECK(!type1->Is(type2) || - (T.Union(type1, type3)->Is(T.Union(type2, type3)))); - } - } - } - - // Monotonicity: T1->Is(T3) and T2->Is(T3) implies Union(T1, T2)->Is(T3) - for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { - for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { - for (TypeIterator it3 = T.types.begin(); it3 != T.types.end(); ++it3) { - TypeHandle type1 = *it1; - TypeHandle type2 = *it2; - TypeHandle type3 = *it3; - CHECK(!(type1->Is(type3) && type2->Is(type3)) || - T.Union(type1, type2)->Is(type3)); - } - } - } + // Bitset-bitset + CHECK(this->IsBitset(T.Union(T.Object, T.Number))); + CHECK(this->IsBitset(T.Union(T.Object, T.Object))); + CHECK(this->IsBitset(T.Union(T.Any, T.None))); - // Monotonicity: T1->Is(T2) or T1->Is(T3) implies T1->Is(Union(T2, T3)) - for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { - for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { - for (TypeIterator it3 = T.types.begin(); it3 != T.types.end(); ++it3) { - TypeHandle type1 = *it1; - TypeHandle type2 = *it2; - TypeHandle type3 = *it3; - CHECK(!(type1->Is(type2) || type1->Is(type3)) || - type1->Is(T.Union(type2, type3))); - } - } - } + CheckEqual(T.Union(T.None, T.Number), T.Number); + CheckEqual(T.Union(T.Object, T.Proxy), T.Receiver); + CheckEqual(T.Union(T.Number, T.String), T.Union(T.String, T.Number)); + CheckSub(T.Union(T.Number, T.String), T.Any); // Class-class + CHECK(this->IsClass(T.Union(T.ObjectClass, T.ObjectClass))); + CHECK(this->IsUnion(T.Union(T.ObjectClass, T.ArrayClass))); + + CheckEqual(T.Union(T.ObjectClass, T.ObjectClass), T.ObjectClass); + CheckSub(T.None, T.Union(T.ObjectClass, T.ArrayClass)); + CheckSub(T.Union(T.ObjectClass, T.ArrayClass), T.Any); + CheckSub(T.ObjectClass, T.Union(T.ObjectClass, T.ArrayClass)); + CheckSub(T.ArrayClass, T.Union(T.ObjectClass, T.ArrayClass)); CheckSub(T.Union(T.ObjectClass, T.ArrayClass), T.Object); CheckUnordered(T.Union(T.ObjectClass, T.ArrayClass), T.Array); CheckOverlap(T.Union(T.ObjectClass, T.ArrayClass), T.Array, T.Semantic); CheckDisjoint(T.Union(T.ObjectClass, T.ArrayClass), T.Number, T.Semantic); // Constant-constant + CHECK(this->IsConstant(T.Union(T.ObjectConstant1, T.ObjectConstant1))); + CHECK(this->IsConstant(T.Union(T.ArrayConstant, T.ArrayConstant))); + CHECK(this->IsUnion(T.Union(T.ObjectConstant1, T.ObjectConstant2))); + + CheckEqual( + T.Union(T.ObjectConstant1, T.ObjectConstant1), + T.ObjectConstant1); + CheckEqual(T.Union(T.ArrayConstant, T.ArrayConstant), T.ArrayConstant); + CheckSub(T.None, T.Union(T.ObjectConstant1, T.ObjectConstant2)); + CheckSub(T.Union(T.ObjectConstant1, T.ObjectConstant2), T.Any); + CheckSub(T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2)); + CheckSub(T.ObjectConstant2, T.Union(T.ObjectConstant1, T.ObjectConstant2)); CheckSub(T.Union(T.ObjectConstant1, T.ObjectConstant2), T.Object); - CheckUnordered(T.Union(T.ObjectConstant1, T.ArrayConstant), T.Array); CheckUnordered( T.Union(T.ObjectConstant1, T.ObjectConstant2), T.ObjectClass); + CheckUnordered(T.Union(T.ObjectConstant1, T.ArrayConstant), T.Array); CheckOverlap( T.Union(T.ObjectConstant1, T.ArrayConstant), T.Array, T.Semantic); CheckDisjoint( T.Union(T.ObjectConstant1, T.ArrayConstant), T.Number, T.Semantic); CheckDisjoint( - T.Union(T.ObjectConstant1, T.ArrayConstant), T.ObjectClass, T.Semantic); + T.Union(T.ObjectConstant1, T.ArrayConstant), T.ObjectClass, + T.Semantic); // Bitset-class + CHECK(this->IsBitset(T.Union(T.ObjectClass, T.Object))); + CHECK(this->IsUnion(T.Union(T.ObjectClass, T.Number))); + + CheckEqual(T.Union(T.ObjectClass, T.Object), T.Object); + CheckSub(T.None, T.Union(T.ObjectClass, T.Number)); + CheckSub(T.Union(T.ObjectClass, T.Number), T.Any); CheckSub( T.Union(T.ObjectClass, T.SignedSmall), T.Union(T.Object, T.Number)); CheckSub(T.Union(T.ObjectClass, T.Array), T.Object); @@ -1056,15 +940,31 @@ struct Tests : Rep { CheckDisjoint(T.Union(T.ObjectClass, T.String), T.Number, T.Semantic); // Bitset-constant + CHECK(this->IsBitset(T.Union(T.SmiConstant, T.Number))); + CHECK(this->IsBitset(T.Union(T.ObjectConstant1, T.Object))); + CHECK(this->IsUnion(T.Union(T.ObjectConstant2, T.Number))); + + CheckEqual(T.Union(T.SmiConstant, T.Number), T.Number); + CheckEqual(T.Union(T.ObjectConstant1, T.Object), T.Object); + CheckSub(T.None, T.Union(T.ObjectConstant1, T.Number)); + CheckSub(T.Union(T.ObjectConstant1, T.Number), T.Any); CheckSub( T.Union(T.ObjectConstant1, T.Signed32), T.Union(T.Object, T.Number)); CheckSub(T.Union(T.ObjectConstant1, T.Array), T.Object); CheckUnordered(T.Union(T.ObjectConstant1, T.String), T.Array); CheckOverlap(T.Union(T.ObjectConstant1, T.String), T.Object, T.Semantic); CheckDisjoint(T.Union(T.ObjectConstant1, T.String), T.Number, T.Semantic); + CheckEqual(T.Union(T.Signed32, T.Signed32Constant), T.Signed32); // Class-constant + CHECK(this->IsUnion(T.Union(T.ObjectConstant1, T.ObjectClass))); + CHECK(this->IsUnion(T.Union(T.ArrayClass, T.ObjectConstant2))); + + CheckSub(T.None, T.Union(T.ObjectConstant1, T.ArrayClass)); + CheckSub(T.Union(T.ObjectConstant1, T.ArrayClass), T.Any); CheckSub(T.Union(T.ObjectConstant1, T.ArrayClass), T.Object); + CheckSub(T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ArrayClass)); + CheckSub(T.ArrayClass, T.Union(T.ObjectConstant1, T.ArrayClass)); CheckUnordered(T.ObjectClass, T.Union(T.ObjectConstant1, T.ArrayClass)); CheckSub( T.Union(T.ObjectConstant1, T.ArrayClass), T.Union(T.Array, T.Object)); @@ -1076,14 +976,48 @@ struct Tests : Rep { T.Union(T.ObjectConstant1, T.ArrayClass), T.ObjectClass, T.Semantic); // Bitset-union + CHECK(this->IsBitset( + T.Union(T.Object, T.Union(T.ObjectConstant1, T.ObjectClass)))); + CHECK(this->IsUnion( + T.Union(T.Union(T.ArrayClass, T.ObjectConstant2), T.Number))); + + CheckEqual( + T.Union(T.Object, T.Union(T.ObjectConstant1, T.ObjectClass)), + T.Object); + CheckEqual( + T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Number), + T.Union(T.ObjectConstant1, T.Union(T.Number, T.ArrayClass))); CheckSub( T.Float, T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Number)); CheckSub( + T.ObjectConstant1, + T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Float)); + CheckSub( + T.None, + T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Float)); + CheckSub( + T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Float), + T.Any); + CheckSub( T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Float), T.Union(T.ObjectConstant1, T.Union(T.Number, T.ArrayClass))); // Class-union + CHECK(this->IsUnion( + T.Union(T.Union(T.ArrayClass, T.ObjectConstant2), T.ArrayClass))); + CHECK(this->IsUnion( + T.Union(T.Union(T.ArrayClass, T.ObjectConstant2), T.ObjectClass))); + + CheckEqual( + T.Union(T.ObjectClass, T.Union(T.ObjectConstant1, T.ObjectClass)), + T.Union(T.ObjectClass, T.ObjectConstant1)); + CheckSub( + T.None, + T.Union(T.ObjectClass, T.Union(T.ObjectConstant1, T.ObjectClass))); + CheckSub( + T.Union(T.ObjectClass, T.Union(T.ObjectConstant1, T.ObjectClass)), + T.Any); CheckSub( T.Union(T.ObjectClass, T.Union(T.ObjectConstant1, T.ObjectClass)), T.Object); @@ -1092,6 +1026,13 @@ struct Tests : Rep { T.Union(T.ArrayClass, T.ObjectConstant2)); // Constant-union + CHECK(this->IsUnion(T.Union( + T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2)))); + CHECK(this->IsUnion(T.Union( + T.Union(T.ArrayConstant, T.ObjectClass), T.ObjectConstant1))); + CHECK(this->IsUnion(T.Union( + T.Union(T.ArrayConstant, T.ObjectConstant2), T.ObjectConstant1))); + CheckEqual( T.Union( T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2)), @@ -1103,6 +1044,13 @@ struct Tests : Rep { T.ObjectConstant2, T.Union(T.ArrayConstant, T.ObjectConstant1))); // Union-union + CHECK(this->IsBitset(T.Union( + T.Union(T.Number, T.ArrayClass), + T.Union(T.Signed32, T.Array)))); + CHECK(this->IsUnion(T.Union( + T.Union(T.Number, T.ArrayClass), + T.Union(T.ObjectClass, T.ArrayClass)))); + CheckEqual( T.Union( T.Union(T.ObjectConstant2, T.ObjectConstant1), @@ -1116,129 +1064,61 @@ struct Tests : Rep { } void Intersect() { - // Identity: Intersect(T, Any) = T - for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { - TypeHandle type = *it; - CheckEqual(T.Intersect(type, T.Any), type); - } - - // Domination: Intersect(T, None) = None - for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { - TypeHandle type = *it; - CheckEqual(T.Intersect(type, T.None), T.None); - } - - // Idempotence: Intersect(T, T) = T - for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) { - TypeHandle type = *it; - CheckEqual(T.Intersect(type, type), type); - } - - // Commutativity: Intersect(T1, T2) = Intersect(T2, T1) - for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { - for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { - TypeHandle type1 = *it1; - TypeHandle type2 = *it2; - CheckEqual(T.Intersect(type1, type2), T.Intersect(type2, type1)); - } - } - - // Associativity: - // Intersect(T1, Intersect(T2, T3)) = Intersect(Intersect(T1, T2), T3) - for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { - for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { - for (TypeIterator it3 = T.types.begin(); it3 != T.types.end(); ++it3) { - TypeHandle type1 = *it1; - TypeHandle type2 = *it2; - TypeHandle type3 = *it3; - CheckEqual( - T.Intersect(type1, T.Intersect(type2, type3)), - T.Intersect(T.Intersect(type1, type2), type3)); - } - } - } - - // Join: Intersect(T1, T2)->Is(T1) and Intersect(T1, T2)->Is(T2) - for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { - for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { - TypeHandle type1 = *it1; - TypeHandle type2 = *it2; - CHECK(T.Intersect(type1, type2)->Is(type1)); - CHECK(T.Intersect(type1, type2)->Is(type2)); - } - } + // Bitset-bitset + CHECK(this->IsBitset(T.Intersect(T.Object, T.Number))); + CHECK(this->IsBitset(T.Intersect(T.Object, T.Object))); + CHECK(this->IsBitset(T.Intersect(T.Any, T.None))); - // Lower Boundedness: T1->Is(T2) implies Intersect(T1, T2) = T1 - for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { - for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { - TypeHandle type1 = *it1; - TypeHandle type2 = *it2; - if (type1->Is(type2)) CheckEqual(T.Intersect(type1, type2), type1); - } - } + CheckEqual(T.Intersect(T.None, T.Number), T.None); + CheckSub(T.Intersect(T.Object, T.Proxy), T.Representation); + CheckEqual(T.Intersect(T.Name, T.String), T.Intersect(T.String, T.Name)); + CheckEqual(T.Intersect(T.UniqueName, T.String), T.InternalizedString); - // Monotonicity: T1->Is(T2) implies Intersect(T1, T3)->Is(Intersect(T2, T3)) - for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { - for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { - for (TypeIterator it3 = T.types.begin(); it3 != T.types.end(); ++it3) { - TypeHandle type1 = *it1; - TypeHandle type2 = *it2; - TypeHandle type3 = *it3; - CHECK(!type1->Is(type2) || - (T.Intersect(type1, type3)->Is(T.Intersect(type2, type3)))); - } - } - } + // Class-class + CHECK(this->IsClass(T.Intersect(T.ObjectClass, T.ObjectClass))); + CHECK(this->IsBitset(T.Intersect(T.ObjectClass, T.ArrayClass))); - // Monotonicity: T1->Is(T2) implies Intersect(T1, T3)->Is(Intersect(T2, T3)) - for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { - for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { - for (TypeIterator it3 = T.types.begin(); it3 != T.types.end(); ++it3) { - TypeHandle type1 = *it1; - TypeHandle type2 = *it2; - TypeHandle type3 = *it3; - CHECK(!type1->Is(type2) || - (T.Intersect(type1, type3)->Is(T.Intersect(type2, type3)))); - } - } - } + CheckEqual(T.Intersect(T.ObjectClass, T.ObjectClass), T.ObjectClass); + CheckEqual(T.Intersect(T.ObjectClass, T.ArrayClass), T.None); - // Monotonicity: T1->Is(T3) or T2->Is(T3) implies Intersect(T1, T2)->Is(T3) - for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { - for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { - for (TypeIterator it3 = T.types.begin(); it3 != T.types.end(); ++it3) { - TypeHandle type1 = *it1; - TypeHandle type2 = *it2; - TypeHandle type3 = *it3; - CHECK(!(type1->Is(type3) || type2->Is(type3)) || - T.Intersect(type1, type2)->Is(type3)); - } - } - } + // Constant-constant + CHECK(this->IsConstant(T.Intersect(T.ObjectConstant1, T.ObjectConstant1))); + CHECK(this->IsBitset(T.Intersect(T.ObjectConstant1, T.ObjectConstant2))); - // Monotonicity: T1->Is(T2) and T1->Is(T3) implies T1->Is(Intersect(T2, T3)) - for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) { - for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) { - for (TypeIterator it3 = T.types.begin(); it3 != T.types.end(); ++it3) { - TypeHandle type1 = *it1; - TypeHandle type2 = *it2; - TypeHandle type3 = *it3; - CHECK(!(type1->Is(type2) && type1->Is(type3)) || - type1->Is(T.Intersect(type2, type3))); - } - } - } + CheckEqual( + T.Intersect(T.ObjectConstant1, T.ObjectConstant1), T.ObjectConstant1); + CheckEqual(T.Intersect(T.ObjectConstant1, T.ObjectConstant2), T.None); // Bitset-class + CHECK(this->IsClass(T.Intersect(T.ObjectClass, T.Object))); + CHECK(this->IsBitset(T.Intersect(T.ObjectClass, T.Number))); + CheckEqual(T.Intersect(T.ObjectClass, T.Object), T.ObjectClass); CheckSub(T.Intersect(T.ObjectClass, T.Array), T.Representation); CheckSub(T.Intersect(T.ObjectClass, T.Number), T.Representation); + // Bitset-constant + CHECK(this->IsBitset(T.Intersect(T.SignedSmall, T.Number))); + CHECK(this->IsConstant(T.Intersect(T.SmiConstant, T.Number))); + CHECK(this->IsConstant(T.Intersect(T.ObjectConstant1, T.Object))); + + CheckEqual(T.Intersect(T.SignedSmall, T.Number), T.SignedSmall); + CheckEqual(T.Intersect(T.SmiConstant, T.Number), T.SmiConstant); + CheckEqual(T.Intersect(T.ObjectConstant1, T.Object), T.ObjectConstant1); + // Class-constant + CHECK(this->IsBitset(T.Intersect(T.ObjectConstant1, T.ObjectClass))); + CHECK(this->IsBitset(T.Intersect(T.ArrayClass, T.ObjectConstant2))); + CheckEqual(T.Intersect(T.ObjectConstant1, T.ObjectClass), T.None); CheckEqual(T.Intersect(T.ArrayClass, T.ObjectConstant2), T.None); // Bitset-union + CHECK(this->IsUnion( + T.Intersect(T.Object, T.Union(T.ObjectConstant1, T.ObjectClass)))); + CHECK(this->IsBitset( + T.Intersect(T.Union(T.ArrayClass, T.ObjectConstant2), T.Number))); + CheckEqual( T.Intersect(T.Object, T.Union(T.ObjectConstant1, T.ObjectClass)), T.Union(T.ObjectConstant1, T.ObjectClass)); @@ -1247,6 +1127,13 @@ struct Tests : Rep { T.None); // Class-union + CHECK(this->IsClass( + T.Intersect(T.Union(T.ArrayClass, T.ObjectConstant2), T.ArrayClass))); + CHECK(this->IsClass( + T.Intersect(T.Union(T.Object, T.SmiConstant), T.ArrayClass))); + CHECK(this->IsBitset( + T.Intersect(T.Union(T.ObjectClass, T.ArrayConstant), T.ArrayClass))); + CheckEqual( T.Intersect(T.ArrayClass, T.Union(T.ObjectConstant2, T.ArrayClass)), T.ArrayClass); @@ -1258,6 +1145,13 @@ struct Tests : Rep { T.None); // Constant-union + CHECK(this->IsConstant(T.Intersect( + T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2)))); + CHECK(this->IsConstant(T.Intersect( + T.Union(T.Number, T.ObjectClass), T.SmiConstant))); + CHECK(this->IsBitset(T.Intersect( + T.Union(T.ArrayConstant, T.ObjectClass), T.ObjectConstant1))); + CheckEqual( T.Intersect( T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2)), @@ -1271,6 +1165,11 @@ struct Tests : Rep { T.None); // Union-union + CHECK(this->IsUnion(T.Intersect( + T.Union(T.Number, T.ArrayClass), T.Union(T.Signed32, T.Array)))); + CHECK(this->IsBitset(T.Intersect( + T.Union(T.Number, T.ObjectClass), T.Union(T.Signed32, T.Array)))); + CheckEqual( T.Intersect( T.Union(T.Number, T.ArrayClass),