Revision: 20884
Author: [email protected]
Date: Tue Apr 22 11:44:06 2014 UTC
Log: Collective fixes to types
[email protected]
BUG=
Review URL: https://codereview.chromium.org/247273002
http://code.google.com/p/v8/source/detail?r=20884
Modified:
/branches/3.25/src/types.cc
/branches/3.25/src/types.h
/branches/3.25/test/cctest/test-types.cc
=======================================
--- /branches/3.25/src/types.cc Mon Apr 7 10:47:54 2014 UTC
+++ /branches/3.25/src/types.cc Tue Apr 22 11:44:06 2014 UTC
@@ -337,14 +337,6 @@
// Check this overlaps that.
template<class Config>
bool TypeImpl<Config>::Maybe(TypeImpl* that) {
- // Fast path for bitsets.
- if (this->IsBitset()) {
- return IsInhabited(this->AsBitset() & that->LubBitset());
- }
- if (that->IsBitset()) {
- return IsInhabited(this->LubBitset() & that->AsBitset());
- }
-
// (T1 \/ ... \/ Tn) overlaps T <=> (T1 overlaps T) \/ ... \/ (Tn
overlaps T)
if (this->IsUnion()) {
UnionedHandle unioned = this->AsUnion();
@@ -366,6 +358,12 @@
}
ASSERT(!this->IsUnion() && !that->IsUnion());
+ if (this->IsBitset()) {
+ return IsInhabited(this->AsBitset() & that->LubBitset());
+ }
+ if (that->IsBitset()) {
+ return IsInhabited(this->LubBitset() & that->AsBitset());
+ }
if (this->IsClass()) {
return that->IsClass() && *this->AsClass() == *that->AsClass();
}
@@ -442,12 +440,12 @@
size += (type2->IsUnion() ? Config::union_length(type2->AsUnion()) :
1);
}
int bitset = type1->GlbBitset() | type2->GlbBitset();
- if (IsInhabited(bitset)) ++size;
+ if (bitset != kNone) ++size;
ASSERT(size >= 1);
UnionedHandle unioned = Config::union_create(size, region);
size = 0;
- if (IsInhabited(bitset)) {
+ if (bitset != kNone) {
Config::union_set(unioned, size++, Config::from_bitset(bitset,
region));
}
size = ExtendUnion(unioned, type1, size);
@@ -509,21 +507,20 @@
}
// Slow case: may need to produce a Unioned object.
- int size = INT_MAX;
+ int size = 0;
if (!type1->IsBitset()) {
- size = (type1->IsUnion() ? Config::union_length(type1->AsUnion()) : 1);
+ size += (type1->IsUnion() ? Config::union_length(type1->AsUnion()) :
1);
}
if (!type2->IsBitset()) {
- size = Min(size,
- type2->IsUnion() ? Config::union_length(type2->AsUnion()) :
1);
+ size += (type2->IsUnion() ? Config::union_length(type2->AsUnion()) :
1);
}
int bitset = type1->GlbBitset() & type2->GlbBitset();
- if (IsInhabited(bitset)) ++size;
+ if (bitset != kNone) ++size;
ASSERT(size >= 1);
UnionedHandle unioned = Config::union_create(size, region);
size = 0;
- if (IsInhabited(bitset)) {
+ if (bitset != kNone) {
Config::union_set(unioned, size++, Config::from_bitset(bitset,
region));
}
size = ExtendIntersection(unioned, type1, type2, size);
@@ -655,11 +652,11 @@
}
} else if (this->IsConstant()) {
PrintF(out, "Constant(%p : ", static_cast<void*>(*this->AsConstant()));
- Config::from_bitset(this->LubBitset())->TypePrint(out);
+ Config::from_bitset(this->LubBitset())->TypePrint(out, dim);
PrintF(out, ")");
} else if (this->IsClass()) {
PrintF(out, "Class(%p < ", static_cast<void*>(*this->AsClass()));
- Config::from_bitset(this->LubBitset())->TypePrint(out);
+ Config::from_bitset(this->LubBitset())->TypePrint(out, dim);
PrintF(out, ")");
} else if (this->IsUnion()) {
PrintF(out, "(");
=======================================
--- /branches/3.25/src/types.h Tue Mar 18 13:03:00 2014 UTC
+++ /branches/3.25/src/types.h Tue Apr 22 11:44:06 2014 UTC
@@ -181,7 +181,7 @@
V(Object, kDetectableObject | kUndetectable) \
V(Receiver, kObject | kProxy) \
V(NonNumber, kOddball | kName | kReceiver | kInternal) \
- V(Any, kNumber | kNonNumber)
+ V(Any, -1)
#define BITSET_TYPE_LIST(V) \
MASK_BITSET_TYPE_LIST(V) \
=======================================
--- /branches/3.25/test/cctest/test-types.cc Tue Mar 18 13:03:00 2014 UTC
+++ /branches/3.25/test/cctest/test-types.cc Tue Apr 22 11:44:06 2014 UTC
@@ -25,77 +25,126 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#include <vector>
+
#include "cctest.h"
#include "types.h"
+#include "utils/random-number-generator.h"
using namespace v8::internal;
+// Testing auxiliaries (breaking the Type abstraction).
+struct ZoneRep {
+ typedef ZoneList<void*> Struct;
+
+ static bool IsStruct(Type* t, int tag) {
+ return !IsBitset(t)
+ && reinterpret_cast<intptr_t>(AsStruct(t)->at(0)) == tag;
+ }
+ static bool IsBitset(Type* t) { return reinterpret_cast<intptr_t>(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<Struct*>(t);
+ }
+ static int AsBitset(Type* t) {
+ return static_cast<int>(reinterpret_cast<intptr_t>(t) >> 1);
+ }
+ static Map* AsClass(Type* t) {
+ return *static_cast<Map**>(AsStruct(t)->at(2));
+ }
+ static Object* AsConstant(Type* t) {
+ return *static_cast<Object**>(AsStruct(t)->at(2));
+ }
+ static Struct* AsUnion(Type* t) {
+ return AsStruct(t);
+ }
+ static int Length(Struct* structured) { return structured->length() - 2;
}
+
+ static Zone* ToRegion(Zone* zone, Isolate* isolate) { return zone; }
+};
+
+
+struct HeapRep {
+ static bool IsBitset(Handle<HeapType> t) { return t->IsSmi(); }
+ static bool IsClass(Handle<HeapType> t) { return t->IsMap(); }
+ static bool IsConstant(Handle<HeapType> t) { return t->IsBox(); }
+ static bool IsUnion(Handle<HeapType> t) { return t->IsFixedArray(); }
+
+ static int AsBitset(Handle<HeapType> t) { return Smi::cast(*t)->value();
}
+ static Map* AsClass(Handle<HeapType> t) { return Map::cast(*t); }
+ static Object* AsConstant(Handle<HeapType> t) {
+ return Box::cast(*t)->value();
+ }
+ static FixedArray* AsUnion(Handle<HeapType> t) {
+ return FixedArray::cast(*t);
+ }
+ static int Length(FixedArray* structured) { return structured->length();
}
+
+ static Isolate* ToRegion(Zone* zone, Isolate* isolate) { return isolate;
}
+};
+
+
template<class Type, class TypeHandle, class Region>
class Types {
public:
- Types(Region* region, Isolate* isolate) :
- Representation(Type::Representation(region)),
- Semantic(Type::Semantic(region)),
- None(Type::None(region)),
- Any(Type::Any(region)),
- Oddball(Type::Oddball(region)),
- Boolean(Type::Boolean(region)),
- Null(Type::Null(region)),
- Undefined(Type::Undefined(region)),
- Number(Type::Number(region)),
- SignedSmall(Type::SignedSmall(region)),
- Signed32(Type::Signed32(region)),
- Float(Type::Float(region)),
- Name(Type::Name(region)),
- UniqueName(Type::UniqueName(region)),
- String(Type::String(region)),
- InternalizedString(Type::InternalizedString(region)),
- Symbol(Type::Symbol(region)),
- Receiver(Type::Receiver(region)),
- Object(Type::Object(region)),
- Array(Type::Array(region)),
- Function(Type::Function(region)),
- Proxy(Type::Proxy(region)),
- object_map(isolate->factory()->NewMap(JS_OBJECT_TYPE, 3 *
kPointerSize)),
- array_map(isolate->factory()->NewMap(JS_ARRAY_TYPE, 4 *
kPointerSize)),
- region_(region) {
+ Types(Region* region, Isolate* isolate) : region_(region) {
+ #define DECLARE_TYPE(name, value) \
+ name = Type::name(region); \
+ types.push_back(name);
+ BITSET_TYPE_LIST(DECLARE_TYPE)
+ #undef DECLARE_TYPE
+
+ object_map = isolate->factory()->NewMap(JS_OBJECT_TYPE, 3 *
kPointerSize);
+ array_map = isolate->factory()->NewMap(JS_ARRAY_TYPE, 4 *
kPointerSize);
+ ObjectClass = Type::Class(object_map, region);
+ ArrayClass = Type::Class(array_map, region);
+
+ maps.push_back(object_map);
+ maps.push_back(array_map);
+ for (MapVector::iterator it = maps.begin(); it != maps.end(); ++it) {
+ types.push_back(Type::Class(*it, region));
+ }
+
smi = handle(Smi::FromInt(666), isolate);
signed32 = isolate->factory()->NewHeapNumber(0x40000000);
object1 = isolate->factory()->NewJSObjectFromMap(object_map);
object2 = isolate->factory()->NewJSObjectFromMap(object_map);
array = isolate->factory()->NewJSArray(20);
- ObjectClass = Type::Class(object_map, region);
- ArrayClass = Type::Class(array_map, region);
SmiConstant = Type::Constant(smi, region);
Signed32Constant = Type::Constant(signed32, region);
ObjectConstant1 = Type::Constant(object1, region);
ObjectConstant2 = Type::Constant(object2, region);
- ArrayConstant1 = Type::Constant(array, region);
- ArrayConstant2 = Type::Constant(array, region);
+ ArrayConstant = Type::Constant(array, region);
+
+ values.push_back(smi);
+ values.push_back(signed32);
+ values.push_back(object1);
+ values.push_back(object2);
+ values.push_back(array);
+ for (ValueVector::iterator it = values.begin(); it != values.end();
++it) {
+ types.push_back(Type::Constant(*it, region));
+ }
+
+ for (int i = 0; i < 50; ++i) {
+ types.push_back(Fuzz());
+ }
}
- TypeHandle Representation;
- TypeHandle Semantic;
- TypeHandle None;
- TypeHandle Any;
- TypeHandle Oddball;
- TypeHandle Boolean;
- TypeHandle Null;
- TypeHandle Undefined;
- TypeHandle Number;
- TypeHandle SignedSmall;
- TypeHandle Signed32;
- TypeHandle Float;
- TypeHandle Name;
- TypeHandle UniqueName;
- TypeHandle String;
- TypeHandle InternalizedString;
- TypeHandle Symbol;
- TypeHandle Receiver;
- TypeHandle Object;
- TypeHandle Array;
- TypeHandle Function;
- TypeHandle Proxy;
+ Handle<i::Map> object_map;
+ Handle<i::Map> array_map;
+
+ Handle<i::Smi> smi;
+ Handle<i::HeapNumber> signed32;
+ Handle<i::JSObject> object1;
+ Handle<i::JSObject> object2;
+ Handle<i::JSArray> array;
+
+ #define DECLARE_TYPE(name, value) TypeHandle name;
+ BITSET_TYPE_LIST(DECLARE_TYPE)
+ #undef DECLARE_TYPE
TypeHandle ObjectClass;
TypeHandle ArrayClass;
@@ -104,17 +153,30 @@
TypeHandle Signed32Constant;
TypeHandle ObjectConstant1;
TypeHandle ObjectConstant2;
- TypeHandle ArrayConstant1;
- TypeHandle ArrayConstant2;
+ TypeHandle ArrayConstant;
- Handle<i::Map> object_map;
- Handle<i::Map> array_map;
+ typedef std::vector<TypeHandle> TypeVector;
+ typedef std::vector<Handle<i::Map> > MapVector;
+ typedef std::vector<Handle<i::Object> > ValueVector;
+ TypeVector types;
+ MapVector maps;
+ ValueVector values;
- Handle<i::Smi> smi;
- Handle<i::HeapNumber> signed32;
- Handle<i::JSObject> object1;
- Handle<i::JSObject> object2;
- Handle<i::JSArray> array;
+ TypeHandle Of(Handle<i::Object> value) {
+ return Type::Of(value, region_);
+ }
+
+ TypeHandle NowOf(Handle<i::Object> value) {
+ return Type::NowOf(value, region_);
+ }
+
+ TypeHandle Constant(Handle<i::Object> value) {
+ return Type::Constant(value, region_);
+ }
+
+ TypeHandle Class(Handle<i::Map> map) {
+ return Type::Class(map, region_);
+ }
TypeHandle Union(TypeHandle t1, TypeHandle t2) {
return Type::Union(t1, t2, region_);
@@ -127,43 +189,40 @@
TypeHandle Convert(TypeHandle2 t) {
return Type::template Convert<Type2>(t, region_);
}
+
+ TypeHandle Random() {
+ return types[rng_.NextInt(static_cast<int>(types.size()))];
+ }
TypeHandle Fuzz(int depth = 5) {
- switch (rand() % (depth == 0 ? 3 : 20)) {
+ 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 = rand() % n;
+ 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
- switch (rand() % 2) {
- case 0: return ObjectClass;
- case 1: return ArrayClass;
- }
- UNREACHABLE();
- case 2: // constant
- switch (rand() % 6) {
- case 0: return SmiConstant;
- case 1: return Signed32Constant;
- case 2: return ObjectConstant1;
- case 3: return ObjectConstant2;
- case 4: return ArrayConstant1;
- case 5: return ArrayConstant2;
- }
- UNREACHABLE();
+ case 1: { // class
+ int i = rng_.NextInt(static_cast<int>(maps.size()));
+ return Type::Class(maps[i], region_);
+ }
+ case 2: { // constant
+ int i = rng_.NextInt(static_cast<int>(values.size()));
+ return Type::Constant(values[i], region_);
+ }
default: { // union
- int n = rand() % 10;
+ int n = rng_.NextInt(10);
TypeHandle type = None;
for (int i = 0; i < n; ++i) {
- type = Type::Union(type, Fuzz(depth - 1), region_);
+ TypeHandle operand = Fuzz(depth - 1);
+ type = Type::Union(type, operand, region_);
}
return type;
}
@@ -173,65 +232,21 @@
private:
Region* region_;
-};
-
-
-// Testing auxiliaries (breaking the Type abstraction).
-struct ZoneRep {
- static bool IsTagged(Type* t, int tag) {
- return !IsBitset(t)
- && reinterpret_cast<intptr_t>(AsTagged(t)->at(0)) == tag;
- }
- static bool IsBitset(Type* t) { return reinterpret_cast<intptr_t>(t) &
1; }
- static bool IsClass(Type* t) { return IsTagged(t, 0); }
- static bool IsConstant(Type* t) { return IsTagged(t, 1); }
- static bool IsUnion(Type* t) { return IsTagged(t, 2); }
-
- static ZoneList<void*>* AsTagged(Type* t) {
- return reinterpret_cast<ZoneList<void*>*>(t);
- }
- static int AsBitset(Type* t) {
- return static_cast<int>(reinterpret_cast<intptr_t>(t) >> 1);
- }
- static Map* AsClass(Type* t) {
- return *reinterpret_cast<Map**>(AsTagged(t)->at(2));
- }
- static Object* AsConstant(Type* t) {
- return *reinterpret_cast<Object**>(AsTagged(t)->at(2));
- }
- static ZoneList<Type*>* AsUnion(Type* t) {
- return reinterpret_cast<ZoneList<Type*>*>(AsTagged(t));
- }
-
- static Zone* ToRegion(Zone* zone, Isolate* isolate) { return zone; }
-};
-
-
-struct HeapRep {
- static bool IsBitset(Handle<HeapType> t) { return t->IsSmi(); }
- static bool IsClass(Handle<HeapType> t) { return t->IsMap(); }
- static bool IsConstant(Handle<HeapType> t) { return t->IsBox(); }
- static bool IsUnion(Handle<HeapType> t) { return t->IsFixedArray(); }
-
- static int AsBitset(Handle<HeapType> t) { return Smi::cast(*t)->value();
}
- static Map* AsClass(Handle<HeapType> t) { return Map::cast(*t); }
- static Object* AsConstant(Handle<HeapType> t) {
- return Box::cast(*t)->value();
- }
- static FixedArray* AsUnion(Handle<HeapType> t) {
- return FixedArray::cast(*t);
- }
-
- static Isolate* ToRegion(Zone* zone, Isolate* isolate) { return isolate;
}
+ RandomNumberGenerator rng_;
};
template<class Type, class TypeHandle, class Region, class Rep>
struct Tests : Rep {
+ typedef Types<Type, TypeHandle, Region> TypesInstance;
+ typedef typename TypesInstance::TypeVector::iterator TypeIterator;
+ typedef typename TypesInstance::MapVector::iterator MapIterator;
+ typedef typename TypesInstance::ValueVector::iterator ValueIterator;
+
Isolate* isolate;
HandleScope scope;
Zone zone;
- Types<Type, TypeHandle, Region> T;
+ TypesInstance T;
Tests() :
isolate(CcTest::i_isolate()),
@@ -239,25 +254,28 @@
zone(isolate),
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_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::AsUnion(type1)->length(),
Rep::AsUnion(type2)->length());
- }
- CHECK(type1->Is(type2));
- CHECK(type2->Is(type1));
+ CHECK(Equal(type1, type2));
}
void CheckSub(TypeHandle type1, TypeHandle type2) {
@@ -297,69 +315,252 @@
}
void Bitset() {
+ // None and Any are bitsets.
CHECK(this->IsBitset(T.None));
CHECK(this->IsBitset(T.Any));
- CHECK(this->IsBitset(T.String));
- CHECK(this->IsBitset(T.Object));
-
- CHECK(this->IsBitset(T.Union(T.String, T.Number)));
- CHECK(this->IsBitset(T.Union(T.String, T.Receiver)));
CHECK_EQ(0, this->AsBitset(T.None));
- CHECK_EQ(
- this->AsBitset(T.Number) | this->AsBitset(T.String),
- this->AsBitset(T.Union(T.String, T.Number)));
- CHECK_EQ(
- this->AsBitset(T.Receiver),
- this->AsBitset(T.Union(T.Receiver, T.Object)));
+ CHECK_EQ(-1, this->AsBitset(T.Any));
+
+ // Union(T1, T2) is bitset for 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;
+ TypeHandle type2 = *it2;
+ TypeHandle union12 = T.Union(type1, type2);
+ CHECK(!(this->IsBitset(type1) && this->IsBitset(type2)) ||
+ this->IsBitset(union12));
+ }
+ }
+
+ // Intersect(T1, T2) is bitset for 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;
+ TypeHandle type2 = *it2;
+ TypeHandle intersect12 = T.Intersect(type1, type2);
+ CHECK(!(this->IsBitset(type1) && this->IsBitset(type2)) ||
+ this->IsBitset(intersect12));
+ }
+ }
+
+ // Union(T1, T2) is bitset if T2 is bitset and T1->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;
+ TypeHandle union12 = T.Union(type1, type2);
+ CHECK(!(this->IsBitset(type2) && type1->Is(type2)) ||
+ this->IsBitset(union12));
+ }
+ }
+
+ // Union(T1, T2) is bitwise disjunction for 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;
+ TypeHandle type2 = *it2;
+ TypeHandle union12 = T.Union(type1, type2);
+ if (this->IsBitset(type1) && this->IsBitset(type2)) {
+ CHECK_EQ(
+ this->AsBitset(type1) | this->AsBitset(type2),
+ this->AsBitset(union12));
+ }
+ }
+ }
+
+ // Intersect(T1, T2) is bitwise conjunction for 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;
+ TypeHandle type2 = *it2;
+ TypeHandle intersect12 = T.Intersect(type1, type2);
+ if (this->IsBitset(type1) && this->IsBitset(type2)) {
+ CHECK_EQ(
+ this->AsBitset(type1) & this->AsBitset(type2),
+ this->AsBitset(intersect12));
+ }
+ }
+ }
}
void Class() {
- CHECK(this->IsClass(T.ObjectClass));
- CHECK(this->IsClass(T.ArrayClass));
+ // Constructor
+ for (MapIterator mt = T.maps.begin(); mt != T.maps.end(); ++mt) {
+ Handle<i::Map> map = *mt;
+ TypeHandle type = T.Class(map);
+ CHECK(this->IsClass(type));
+ }
- CHECK(*T.object_map == this->AsClass(T.ObjectClass));
- CHECK(*T.array_map == this->AsClass(T.ArrayClass));
+ // Map attribute
+ for (MapIterator mt = T.maps.begin(); mt != T.maps.end(); ++mt) {
+ Handle<i::Map> map = *mt;
+ TypeHandle type = T.Class(map);
+ CHECK(*map == *type->AsClass());
+ }
+
+ // Functionality & Injectivity: Class(M1) = Class(M2) iff M1 = M2
+ for (MapIterator mt1 = T.maps.begin(); mt1 != T.maps.end(); ++mt1) {
+ for (MapIterator mt2 = T.maps.begin(); mt2 != T.maps.end(); ++mt2) {
+ Handle<i::Map> map1 = *mt1;
+ Handle<i::Map> map2 = *mt2;
+ TypeHandle type1 = T.Class(map1);
+ TypeHandle type2 = T.Class(map2);
+ CHECK(Equal(type1, type2) == (*map1 == *map2));
+ }
+ }
}
void Constant() {
- CHECK(this->IsConstant(T.SmiConstant));
- CHECK(this->IsConstant(T.ObjectConstant1));
- CHECK(this->IsConstant(T.ObjectConstant2));
- CHECK(this->IsConstant(T.ArrayConstant1));
- CHECK(this->IsConstant(T.ArrayConstant2));
+ // Constructor
+ for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) {
+ Handle<i::Object> value = *vt;
+ TypeHandle type = T.Constant(value);
+ CHECK(this->IsConstant(type));
+ }
- CHECK(*T.smi == this->AsConstant(T.SmiConstant));
- CHECK(*T.object1 == this->AsConstant(T.ObjectConstant1));
- CHECK(*T.object2 == this->AsConstant(T.ObjectConstant2));
- CHECK(*T.object1 != this->AsConstant(T.ObjectConstant2));
- CHECK(*T.array == this->AsConstant(T.ArrayConstant1));
- CHECK(*T.array == this->AsConstant(T.ArrayConstant2));
+ // Value attribute
+ for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) {
+ Handle<i::Object> value = *vt;
+ TypeHandle type = T.Constant(value);
+ CHECK(*value == *type->AsConstant());
+ }
+
+ // Functionality & Injectivity: Constant(V1) = 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) {
+ Handle<i::Object> value1 = *vt1;
+ Handle<i::Object> value2 = *vt2;
+ TypeHandle type1 = T.Constant(value1);
+ TypeHandle type2 = T.Constant(value2);
+ CHECK(Equal(type1, type2) == (*value1 == *value2));
+ }
+ }
+ }
+
+ void Of() {
+ // Constant(V)->Is(Of(V))
+ for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) {
+ Handle<i::Object> value = *vt;
+ TypeHandle const_type = T.Constant(value);
+ TypeHandle of_type = T.Of(value);
+ CHECK(const_type->Is(of_type));
+ }
+
+ // Constant(V)->Is(T) iff 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<i::Object> value = *vt;
+ TypeHandle type = *it;
+ TypeHandle const_type = T.Constant(value);
+ TypeHandle of_type = T.Of(value);
+ CHECK(const_type->Is(type) ==
+ (of_type->Is(type) || type->Maybe(const_type)));
+ }
+ }
}
void Is() {
- // Reflexivity
- CHECK(T.None->Is(T.None));
- CHECK(T.Any->Is(T.Any));
- CHECK(T.Object->Is(T.Object));
+ // Least Element (Bottom): None->Is(T)
+ for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) {
+ TypeHandle type = *it;
+ CHECK(T.None->Is(type));
+ }
- CHECK(T.ObjectClass->Is(T.ObjectClass));
- CHECK(T.ObjectConstant1->Is(T.ObjectConstant1));
- CHECK(T.ArrayConstant1->Is(T.ArrayConstant2));
+ // Greatest Element (Top): T->Is(Any)
+ for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) {
+ TypeHandle type = *it;
+ CHECK(type->Is(T.Any));
+ }
- // Symmetry and Transitivity
- CheckSub(T.None, T.Number);
- CheckSub(T.None, T.Any);
+ // Bottom Uniqueness: T->Is(None) implies T = None
+ for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) {
+ TypeHandle type = *it;
+ if (type->Is(T.None)) CheckEqual(type, T.None);
+ }
- CheckSub(T.Oddball, T.Any);
- CheckSub(T.Boolean, T.Oddball);
- CheckSub(T.Null, T.Oddball);
- CheckSub(T.Undefined, T.Oddball);
+ // Top Uniqueness: Any->Is(T) implies T = Any
+ for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) {
+ TypeHandle type = *it;
+ if (T.Any->Is(type)) CheckEqual(type, T.Any);
+ }
+
+ // Reflexivity: T->Is(T)
+ 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)
+ 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) && type2->Is(type3)) ||
type1->Is(type3));
+ }
+ }
+ }
+
+ // 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) {
+ Handle<i::Object> value1 = *vt1;
+ Handle<i::Object> value2 = *vt2;
+ TypeHandle const_type1 = T.Constant(value1);
+ TypeHandle const_type2 = T.Constant(value2);
+ CHECK(const_type1->Is(const_type2) == (*value1 == *value2));
+ }
+ }
+
+ // Class(M1)->Is(Class(M2)) iff M1 = M2
+ for (MapIterator mt1 = T.maps.begin(); mt1 != T.maps.end(); ++mt1) {
+ for (MapIterator mt2 = T.maps.begin(); mt2 != T.maps.end(); ++mt2) {
+ Handle<i::Map> map1 = *mt1;
+ Handle<i::Map> map2 = *mt2;
+ TypeHandle class_type1 = T.Class(map1);
+ TypeHandle class_type2 = T.Class(map2);
+ CHECK(class_type1->Is(class_type2) == (*map1 == *map2));
+ }
+ }
+
+ // Constant(V)->Is(Class(M)) never
+ for (MapIterator mt = T.maps.begin(); mt != T.maps.end(); ++mt) {
+ for (ValueIterator vt = T.values.begin(); vt != T.values.end();
++vt) {
+ Handle<i::Map> map = *mt;
+ Handle<i::Object> value = *vt;
+ TypeHandle constant_type = T.Constant(value);
+ TypeHandle class_type = T.Class(map);
+ CHECK(!constant_type->Is(class_type));
+ }
+ }
+
+ // Class(M)->Is(Constant(V)) never
+ for (MapIterator mt = T.maps.begin(); mt != T.maps.end(); ++mt) {
+ for (ValueIterator vt = T.values.begin(); vt != T.values.end();
++vt) {
+ Handle<i::Map> map = *mt;
+ Handle<i::Object> value = *vt;
+ TypeHandle constant_type = T.Constant(value);
+ TypeHandle class_type = T.Class(map);
+ CHECK(!class_type->Is(constant_type));
+ }
+ }
+
+ // Basic types
CheckUnordered(T.Boolean, T.Null);
CheckUnordered(T.Undefined, T.Null);
CheckUnordered(T.Boolean, T.Undefined);
- CheckSub(T.Number, T.Any);
CheckSub(T.SignedSmall, T.Number);
CheckSub(T.Signed32, T.Number);
CheckSub(T.Float, T.Number);
@@ -367,8 +568,6 @@
CheckUnordered(T.SignedSmall, T.Float);
CheckUnordered(T.Signed32, T.Float);
- CheckSub(T.Name, T.Any);
- CheckSub(T.UniqueName, T.Any);
CheckSub(T.UniqueName, T.Name);
CheckSub(T.String, T.Name);
CheckSub(T.InternalizedString, T.String);
@@ -380,8 +579,6 @@
CheckUnordered(T.String, T.Symbol);
CheckUnordered(T.InternalizedString, T.Symbol);
- CheckSub(T.Receiver, T.Any);
- CheckSub(T.Object, T.Any);
CheckSub(T.Object, T.Receiver);
CheckSub(T.Array, T.Object);
CheckSub(T.Function, T.Object);
@@ -389,14 +586,10 @@
CheckUnordered(T.Object, T.Proxy);
CheckUnordered(T.Array, T.Function);
- // Structured subtyping
- CheckSub(T.None, T.ObjectClass);
- CheckSub(T.None, T.ObjectConstant1);
- CheckSub(T.ObjectClass, T.Any);
- CheckSub(T.ObjectConstant1, T.Any);
-
+ // Structural types
CheckSub(T.ObjectClass, T.Object);
CheckSub(T.ArrayClass, T.Object);
+ CheckSub(T.ArrayClass, T.Array);
CheckUnordered(T.ObjectClass, T.ArrayClass);
CheckSub(T.SmiConstant, T.SignedSmall);
@@ -404,37 +597,87 @@
CheckSub(T.SmiConstant, T.Number);
CheckSub(T.ObjectConstant1, T.Object);
CheckSub(T.ObjectConstant2, T.Object);
- CheckSub(T.ArrayConstant1, T.Object);
- CheckSub(T.ArrayConstant1, T.Array);
+ CheckSub(T.ArrayConstant, T.Object);
+ CheckSub(T.ArrayConstant, T.Array);
CheckUnordered(T.ObjectConstant1, T.ObjectConstant2);
- CheckUnordered(T.ObjectConstant1, T.ArrayConstant1);
+ CheckUnordered(T.ObjectConstant1, T.ArrayConstant);
CheckUnordered(T.ObjectConstant1, T.ObjectClass);
CheckUnordered(T.ObjectConstant2, T.ObjectClass);
CheckUnordered(T.ObjectConstant1, T.ArrayClass);
CheckUnordered(T.ObjectConstant2, T.ArrayClass);
- CheckUnordered(T.ArrayConstant1, T.ObjectClass);
+ CheckUnordered(T.ArrayConstant, T.ObjectClass);
}
void Maybe() {
- CheckOverlap(T.Any, T.Any, T.Semantic);
- CheckOverlap(T.Object, T.Object, T.Semantic);
+ // T->Maybe(None) never
+ for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) {
+ TypeHandle type = *it;
+ CHECK(!type->Maybe(T.None));
+ }
- CheckOverlap(T.Oddball, T.Any, T.Semantic);
- CheckOverlap(T.Boolean, T.Oddball, T.Semantic);
- CheckOverlap(T.Null, T.Oddball, T.Semantic);
- CheckOverlap(T.Undefined, T.Oddball, T.Semantic);
+ // Symmetry: T1->Maybe(T2) iff T2->Maybe(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;
+ CHECK(type1->Maybe(type2) == type2->Maybe(type1));
+ }
+ }
+
+ // Constant(V1)->Maybe(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) {
+ Handle<i::Object> value1 = *vt1;
+ Handle<i::Object> value2 = *vt2;
+ TypeHandle const_type1 = T.Constant(value1);
+ TypeHandle const_type2 = T.Constant(value2);
+ CHECK(const_type1->Maybe(const_type2) == (*value1 == *value2));
+ }
+ }
+
+ // Class(M1)->Maybe(Class(M2)) iff M1 = M2
+ for (MapIterator mt1 = T.maps.begin(); mt1 != T.maps.end(); ++mt1) {
+ for (MapIterator mt2 = T.maps.begin(); mt2 != T.maps.end(); ++mt2) {
+ Handle<i::Map> map1 = *mt1;
+ Handle<i::Map> map2 = *mt2;
+ TypeHandle class_type1 = T.Class(map1);
+ TypeHandle class_type2 = T.Class(map2);
+ CHECK(class_type1->Maybe(class_type2) == (*map1 == *map2));
+ }
+ }
+
+ // Constant(V)->Maybe(Class(M)) never
+ for (MapIterator mt = T.maps.begin(); mt != T.maps.end(); ++mt) {
+ for (ValueIterator vt = T.values.begin(); vt != T.values.end();
++vt) {
+ Handle<i::Map> map = *mt;
+ Handle<i::Object> value = *vt;
+ TypeHandle const_type = T.Constant(value);
+ TypeHandle class_type = T.Class(map);
+ CHECK(!const_type->Maybe(class_type));
+ }
+ }
+
+ // Class(M)->Maybe(Constant(V)) never
+ for (MapIterator mt = T.maps.begin(); mt != T.maps.end(); ++mt) {
+ for (ValueIterator vt = T.values.begin(); vt != T.values.end();
++vt) {
+ Handle<i::Map> map = *mt;
+ Handle<i::Object> value = *vt;
+ TypeHandle const_type = T.Constant(value);
+ TypeHandle class_type = T.Class(map);
+ CHECK(!class_type->Maybe(const_type));
+ }
+ }
+
+ // Basic types
CheckDisjoint(T.Boolean, T.Null, T.Semantic);
CheckDisjoint(T.Undefined, T.Null, T.Semantic);
CheckDisjoint(T.Boolean, T.Undefined, T.Semantic);
- CheckOverlap(T.Number, T.Any, T.Semantic);
CheckOverlap(T.SignedSmall, T.Number, T.Semantic);
CheckOverlap(T.Float, T.Number, T.Semantic);
CheckDisjoint(T.Signed32, T.Float, T.Semantic);
- CheckOverlap(T.Name, T.Any, T.Semantic);
- CheckOverlap(T.UniqueName, T.Any, T.Semantic);
CheckOverlap(T.UniqueName, T.Name, T.Semantic);
CheckOverlap(T.String, T.Name, T.Semantic);
CheckOverlap(T.InternalizedString, T.String, T.Semantic);
@@ -446,8 +689,6 @@
CheckDisjoint(T.String, T.Symbol, T.Semantic);
CheckDisjoint(T.InternalizedString, T.Symbol, T.Semantic);
- CheckOverlap(T.Receiver, T.Any, T.Semantic);
- CheckOverlap(T.Object, T.Any, T.Semantic);
CheckOverlap(T.Object, T.Receiver, T.Semantic);
CheckOverlap(T.Array, T.Object, T.Semantic);
CheckOverlap(T.Function, T.Object, T.Semantic);
@@ -455,9 +696,7 @@
CheckDisjoint(T.Object, T.Proxy, T.Semantic);
CheckDisjoint(T.Array, T.Function, T.Semantic);
- CheckOverlap(T.ObjectClass, T.Any, T.Semantic);
- CheckOverlap(T.ObjectConstant1, T.Any, T.Semantic);
-
+ // Structural types
CheckOverlap(T.ObjectClass, T.Object, T.Semantic);
CheckOverlap(T.ArrayClass, T.Object, T.Semantic);
CheckOverlap(T.ObjectClass, T.ObjectClass, T.Semantic);
@@ -470,82 +709,150 @@
CheckDisjoint(T.SmiConstant, T.Float, T.Semantic);
CheckOverlap(T.ObjectConstant1, T.Object, T.Semantic);
CheckOverlap(T.ObjectConstant2, T.Object, T.Semantic);
- CheckOverlap(T.ArrayConstant1, T.Object, T.Semantic);
- CheckOverlap(T.ArrayConstant1, T.Array, T.Semantic);
- CheckOverlap(T.ArrayConstant1, T.ArrayConstant2, T.Semantic);
+ CheckOverlap(T.ArrayConstant, T.Object, T.Semantic);
+ CheckOverlap(T.ArrayConstant, T.Array, T.Semantic);
CheckOverlap(T.ObjectConstant1, T.ObjectConstant1, T.Semantic);
CheckDisjoint(T.ObjectConstant1, T.ObjectConstant2, T.Semantic);
- CheckDisjoint(T.ObjectConstant1, T.ArrayConstant1, T.Semantic);
+ CheckDisjoint(T.ObjectConstant1, T.ArrayConstant, T.Semantic);
CheckDisjoint(T.ObjectConstant1, T.ObjectClass, T.Semantic);
CheckDisjoint(T.ObjectConstant2, T.ObjectClass, T.Semantic);
CheckDisjoint(T.ObjectConstant1, T.ArrayClass, T.Semantic);
CheckDisjoint(T.ObjectConstant2, T.ArrayClass, T.Semantic);
- CheckDisjoint(T.ArrayConstant1, T.ObjectClass, T.Semantic);
+ CheckDisjoint(T.ArrayConstant, T.ObjectClass, T.Semantic);
}
- void Union() {
- // 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)));
+ void Union1() {
+ // Identity: Union(T, None) = T
+ for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) {
+ TypeHandle type = *it;
+ TypeHandle union_type = T.Union(type, T.None);
+ CheckEqual(union_type, type);
+ }
- 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);
+ // Domination: Union(T, Any) = Any
+ for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) {
+ TypeHandle type = *it;
+ TypeHandle union_type = T.Union(type, T.Any);
+ CheckEqual(union_type, T.Any);
+ }
- // Class-class
- CHECK(this->IsClass(T.Union(T.ObjectClass, T.ObjectClass)));
- CHECK(this->IsUnion(T.Union(T.ObjectClass, T.ArrayClass)));
+ // Idempotence: Union(T, T) = T
+ for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) {
+ TypeHandle type = *it;
+ TypeHandle union_type = T.Union(type, type);
+ CheckEqual(union_type, type);
+ }
- 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));
+ // 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;
+ TypeHandle union12 = T.Union(type1, type2);
+ TypeHandle union21 = T.Union(type2, type1);
+ CheckEqual(union12, union21);
+ }
+ }
+
+ // 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;
+ TypeHandle union12 = T.Union(type1, type2);
+ TypeHandle union23 = T.Union(type2, type3);
+ TypeHandle union1_23 = T.Union(type1, union23);
+ TypeHandle union12_3 = T.Union(union12, type3);
+ CheckEqual(union1_23, union12_3);
+ }
+ }
+ }
+
+ // 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;
+ TypeHandle union12 = T.Union(type1, type2);
+ CHECK(type1->Is(union12));
+ CHECK(type2->Is(union12));
+ }
+ }
+
+ // 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;
+ TypeHandle union12 = T.Union(type1, type2);
+ if (type1->Is(type2)) CheckEqual(union12, type2);
+ }
+ }
+ }
+
+ void Union2() {
+ // 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;
+ TypeHandle union13 = T.Union(type1, type3);
+ TypeHandle union23 = T.Union(type2, type3);
+ CHECK(!type1->Is(type2) || union13->Is(union23));
+ }
+ }
+ }
+
+ // 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;
+ TypeHandle union12 = T.Union(type1, type2);
+ CHECK(!(type1->Is(type3) && type2->Is(type3)) ||
union12->Is(type3));
+ }
+ }
+ }
+
+ // 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;
+ TypeHandle union23 = T.Union(type2, type3);
+ CHECK(!(type1->Is(type2) || type1->Is(type3)) ||
type1->Is(union23));
+ }
+ }
+ }
***The diff for this file has been truncated for email.***
--
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
---
You received this message because you are subscribed to the Google Groups "v8-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
For more options, visit https://groups.google.com/d/optout.
