Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1190)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: test/cctest/test-types.cc

Issue 133353005: Revert "Implement zone-allocated types" (Closed) Base URL: https://v8.googlecode.com/svn/branches/bleeding_edge
Patch Set: Created 6 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « src/types.cc ('k') | no next file » | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2013 the V8 project authors. All rights reserved. 1 // Copyright 2013 the V8 project authors. All rights reserved.
2 // Redistribution and use in source and binary forms, with or without 2 // Redistribution and use in source and binary forms, with or without
3 // modification, are permitted provided that the following conditions are 3 // modification, are permitted provided that the following conditions are
4 // met: 4 // met:
5 // 5 //
6 // * Redistributions of source code must retain the above copyright 6 // * Redistributions of source code must retain the above copyright
7 // notice, this list of conditions and the following disclaimer. 7 // notice, this list of conditions and the following disclaimer.
8 // * Redistributions in binary form must reproduce the above 8 // * Redistributions in binary form must reproduce the above
9 // copyright notice, this list of conditions and the following 9 // copyright notice, this list of conditions and the following
10 // disclaimer in the documentation and/or other materials provided 10 // disclaimer in the documentation and/or other materials provided
(...skipping 12 matching lines...) Expand all
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 27
28 #include "cctest.h" 28 #include "cctest.h"
29 #include "types.h" 29 #include "types.h"
30 30
31 using namespace v8::internal; 31 using namespace v8::internal;
32 32
33 template<class Type, class TypeHandle, class Region> 33 // Testing auxiliaries (breaking the Type abstraction).
34 class Types { 34 static bool IsBitset(Handle<Type> t) { return t->IsSmi(); }
35 static bool IsClass(Handle<Type> t) { return t->IsMap(); }
36 static bool IsConstant(Handle<Type> t) { return t->IsBox(); }
37 static bool IsUnion(Handle<Type> t) { return t->IsFixedArray(); }
38
39 static int AsBitset(Handle<Type> t) { return Smi::cast(*t)->value(); }
40 static Map* AsClass(Handle<Type> t) { return Map::cast(*t); }
41 static Object* AsConstant(Handle<Type> t) { return Box::cast(*t)->value(); }
42 static FixedArray* AsUnion(Handle<Type> t) { return FixedArray::cast(*t); }
43
44
45 static void CheckEqual(Handle<Type> type1, Handle<Type> type2) {
46 CHECK_EQ(IsBitset(type1), IsBitset(type2));
47 CHECK_EQ(IsClass(type1), IsClass(type2));
48 CHECK_EQ(IsConstant(type1), IsConstant(type2));
49 CHECK_EQ(IsUnion(type1), IsUnion(type2));
50 CHECK_EQ(type1->NumClasses(), type2->NumClasses());
51 CHECK_EQ(type1->NumConstants(), type2->NumConstants());
52 if (IsBitset(type1)) {
53 CHECK_EQ(AsBitset(type1), AsBitset(type2));
54 } else if (IsClass(type1)) {
55 CHECK_EQ(AsClass(type1), AsClass(type2));
56 } else if (IsConstant(type1)) {
57 CHECK_EQ(AsConstant(type1), AsConstant(type2));
58 } else if (IsUnion(type1)) {
59 CHECK_EQ(AsUnion(type1)->length(), AsUnion(type2)->length());
60 }
61 CHECK(type1->Is(type2));
62 CHECK(type2->Is(type1));
63 }
64
65
66 static void CheckSub(Handle<Type> type1, Handle<Type> type2) {
67 CHECK(type1->Is(type2));
68 CHECK(!type2->Is(type1));
69 if (IsBitset(type1) && IsBitset(type2)) {
70 CHECK_NE(AsBitset(type1), AsBitset(type2));
71 }
72 }
73
74
75 static void CheckUnordered(Handle<Type> type1, Handle<Type> type2) {
76 CHECK(!type1->Is(type2));
77 CHECK(!type2->Is(type1));
78 if (IsBitset(type1) && IsBitset(type2)) {
79 CHECK_NE(AsBitset(type1), AsBitset(type2));
80 }
81 }
82
83
84 static void CheckOverlap(Handle<Type> type1, Handle<Type> type2) {
85 CHECK(type1->Maybe(type2));
86 CHECK(type2->Maybe(type1));
87 if (IsBitset(type1) && IsBitset(type2)) {
88 CHECK_NE(0, AsBitset(type1) & AsBitset(type2));
89 }
90 }
91
92
93 static void CheckDisjoint(Handle<Type> type1, Handle<Type> type2) {
94 CHECK(!type1->Is(type2));
95 CHECK(!type2->Is(type1));
96 CHECK(!type1->Maybe(type2));
97 CHECK(!type2->Maybe(type1));
98 if (IsBitset(type1) && IsBitset(type2)) {
99 CHECK_EQ(0, AsBitset(type1) & AsBitset(type2));
100 }
101 }
102
103
104 class HandlifiedTypes {
35 public: 105 public:
36 Types(Region* region, Isolate* isolate) : 106 explicit HandlifiedTypes(Isolate* isolate) :
37 None(Type::None(region)), 107 None(Type::None(isolate)),
38 Any(Type::Any(region)), 108 Any(Type::Any(isolate)),
39 Oddball(Type::Oddball(region)), 109 Oddball(Type::Oddball(isolate)),
40 Boolean(Type::Boolean(region)), 110 Boolean(Type::Boolean(isolate)),
41 Null(Type::Null(region)), 111 Null(Type::Null(isolate)),
42 Undefined(Type::Undefined(region)), 112 Undefined(Type::Undefined(isolate)),
43 Number(Type::Number(region)), 113 Number(Type::Number(isolate)),
44 Smi(Type::Smi(region)), 114 Smi(Type::Smi(isolate)),
45 Signed32(Type::Signed32(region)), 115 Signed32(Type::Signed32(isolate)),
46 Double(Type::Double(region)), 116 Double(Type::Double(isolate)),
47 Name(Type::Name(region)), 117 Name(Type::Name(isolate)),
48 UniqueName(Type::UniqueName(region)), 118 UniqueName(Type::UniqueName(isolate)),
49 String(Type::String(region)), 119 String(Type::String(isolate)),
50 InternalizedString(Type::InternalizedString(region)), 120 InternalizedString(Type::InternalizedString(isolate)),
51 Symbol(Type::Symbol(region)), 121 Symbol(Type::Symbol(isolate)),
52 Receiver(Type::Receiver(region)), 122 Receiver(Type::Receiver(isolate)),
53 Object(Type::Object(region)), 123 Object(Type::Object(isolate)),
54 Array(Type::Array(region)), 124 Array(Type::Array(isolate)),
55 Function(Type::Function(region)), 125 Function(Type::Function(isolate)),
56 Proxy(Type::Proxy(region)), 126 Proxy(Type::Proxy(isolate)),
57 object_map(isolate->factory()->NewMap(JS_OBJECT_TYPE, 3 * kPointerSize)), 127 object_map(isolate->factory()->NewMap(JS_OBJECT_TYPE, 3 * kPointerSize)),
58 array_map(isolate->factory()->NewMap(JS_ARRAY_TYPE, 4 * kPointerSize)), 128 array_map(isolate->factory()->NewMap(JS_ARRAY_TYPE, 4 * kPointerSize)),
59 region_(region) { 129 isolate_(isolate) {
60 smi = handle(Smi::FromInt(666), isolate); 130 smi = handle(Smi::FromInt(666), isolate);
61 signed32 = isolate->factory()->NewHeapNumber(0x40000000); 131 signed32 = isolate->factory()->NewHeapNumber(0x40000000);
62 object1 = isolate->factory()->NewJSObjectFromMap(object_map); 132 object1 = isolate->factory()->NewJSObjectFromMap(object_map);
63 object2 = isolate->factory()->NewJSObjectFromMap(object_map); 133 object2 = isolate->factory()->NewJSObjectFromMap(object_map);
64 array = isolate->factory()->NewJSArray(20); 134 array = isolate->factory()->NewJSArray(20);
65 ObjectClass = Type::Class(object_map, region); 135 ObjectClass = Type::Class(object_map, isolate);
66 ArrayClass = Type::Class(array_map, region); 136 ArrayClass = Type::Class(array_map, isolate);
67 SmiConstant = Type::Constant(smi, region); 137 SmiConstant = Type::Constant(smi, isolate);
68 Signed32Constant = Type::Constant(signed32, region); 138 Signed32Constant = Type::Constant(signed32, isolate);
69 ObjectConstant1 = Type::Constant(object1, region); 139 ObjectConstant1 = Type::Constant(object1, isolate);
70 ObjectConstant2 = Type::Constant(object2, region); 140 ObjectConstant2 = Type::Constant(object2, isolate);
71 ArrayConstant1 = Type::Constant(array, region); 141 ArrayConstant1 = Type::Constant(array, isolate);
72 ArrayConstant2 = Type::Constant(array, region); 142 ArrayConstant2 = Type::Constant(array, isolate);
73 } 143 }
74 144
75 TypeHandle None; 145 Handle<Type> None;
76 TypeHandle Any; 146 Handle<Type> Any;
77 TypeHandle Oddball; 147 Handle<Type> Oddball;
78 TypeHandle Boolean; 148 Handle<Type> Boolean;
79 TypeHandle Null; 149 Handle<Type> Null;
80 TypeHandle Undefined; 150 Handle<Type> Undefined;
81 TypeHandle Number; 151 Handle<Type> Number;
82 TypeHandle Smi; 152 Handle<Type> Smi;
83 TypeHandle Signed32; 153 Handle<Type> Signed32;
84 TypeHandle Double; 154 Handle<Type> Double;
85 TypeHandle Name; 155 Handle<Type> Name;
86 TypeHandle UniqueName; 156 Handle<Type> UniqueName;
87 TypeHandle String; 157 Handle<Type> String;
88 TypeHandle InternalizedString; 158 Handle<Type> InternalizedString;
89 TypeHandle Symbol; 159 Handle<Type> Symbol;
90 TypeHandle Receiver; 160 Handle<Type> Receiver;
91 TypeHandle Object; 161 Handle<Type> Object;
92 TypeHandle Array; 162 Handle<Type> Array;
93 TypeHandle Function; 163 Handle<Type> Function;
94 TypeHandle Proxy; 164 Handle<Type> Proxy;
95 165
96 TypeHandle ObjectClass; 166 Handle<Type> ObjectClass;
97 TypeHandle ArrayClass; 167 Handle<Type> ArrayClass;
98 168
99 TypeHandle SmiConstant; 169 Handle<Type> SmiConstant;
100 TypeHandle Signed32Constant; 170 Handle<Type> Signed32Constant;
101 TypeHandle ObjectConstant1; 171 Handle<Type> ObjectConstant1;
102 TypeHandle ObjectConstant2; 172 Handle<Type> ObjectConstant2;
103 TypeHandle ArrayConstant1; 173 Handle<Type> ArrayConstant1;
104 TypeHandle ArrayConstant2; 174 Handle<Type> ArrayConstant2;
105 175
106 Handle<i::Map> object_map; 176 Handle<Map> object_map;
107 Handle<i::Map> array_map; 177 Handle<Map> array_map;
108 178
109 Handle<i::Smi> smi; 179 Handle<i::Smi> smi;
110 Handle<i::HeapNumber> signed32; 180 Handle<HeapNumber> signed32;
111 Handle<i::JSObject> object1; 181 Handle<JSObject> object1;
112 Handle<i::JSObject> object2; 182 Handle<JSObject> object2;
113 Handle<i::JSArray> array; 183 Handle<JSArray> array;
114 184
115 TypeHandle Union(TypeHandle t1, TypeHandle t2) { 185 Handle<Type> Union(Handle<Type> t1, Handle<Type> t2) {
116 return Type::Union(t1, t2, region_); 186 return Type::Union(t1, t2, isolate_);
117 } 187 }
118 TypeHandle Intersect(TypeHandle t1, TypeHandle t2) { 188 Handle<Type> Intersect(Handle<Type> t1, Handle<Type> t2) {
119 return Type::Intersect(t1, t2, region_); 189 return Type::Intersect(t1, t2, isolate_);
120 } 190 }
121 191
122 private: 192 private:
123 Region* region_; 193 Isolate* isolate_;
124 }; 194 };
125 195
126 196
127 // Testing auxiliaries (breaking the Type abstraction).
128 struct ZoneRep {
129 static bool IsTagged(ZoneType* t, int tag) {
130 return !IsBitset(t)
131 && reinterpret_cast<intptr_t>(AsTagged(t)->at(0)) == tag;
132 }
133 static bool IsBitset(ZoneType* t) {
134 return reinterpret_cast<intptr_t>(t) & 1;
135 }
136 static bool IsClass(ZoneType* t) { return IsTagged(t, 0); }
137 static bool IsConstant(ZoneType* t) { return IsTagged(t, 1); }
138 static bool IsUnion(ZoneType* t) { return IsTagged(t, 2); }
139
140 static ZoneList<void*>* AsTagged(ZoneType* t) {
141 return reinterpret_cast<ZoneList<void*>*>(t);
142 }
143 static int AsBitset(ZoneType* t) {
144 return reinterpret_cast<intptr_t>(t) >> 1;
145 }
146 static Map* AsClass(ZoneType* t) {
147 return *reinterpret_cast<Map**>(AsTagged(t)->at(1));
148 }
149 static Object* AsConstant(ZoneType* t) {
150 return *reinterpret_cast<Object**>(AsTagged(t)->at(1));
151 }
152 static ZoneList<ZoneType*>* AsUnion(ZoneType* t) {
153 return reinterpret_cast<ZoneList<ZoneType*>*>(AsTagged(t));
154 }
155
156 static Zone* Region(Zone* zone, Isolate* isolate) { return zone; }
157 };
158
159
160 struct HeapRep {
161 static bool IsBitset(Handle<Type> t) { return t->IsSmi(); }
162 static bool IsClass(Handle<Type> t) { return t->IsMap(); }
163 static bool IsConstant(Handle<Type> t) { return t->IsBox(); }
164 static bool IsUnion(Handle<Type> t) { return t->IsFixedArray(); }
165
166 static int AsBitset(Handle<Type> t) { return Smi::cast(*t)->value(); }
167 static Map* AsClass(Handle<Type> t) { return Map::cast(*t); }
168 static Object* AsConstant(Handle<Type> t) { return Box::cast(*t)->value(); }
169 static FixedArray* AsUnion(Handle<Type> t) { return FixedArray::cast(*t); }
170
171 static Isolate* Region(Zone* zone, Isolate* isolate) { return isolate; }
172 };
173
174
175 template<class Type, class TypeHandle, class Region, class Rep>
176 struct Tests : Rep {
177 Isolate* isolate;
178 HandleScope scope;
179 Zone zone;
180 Types<Type, TypeHandle, Region> T;
181
182 Tests() :
183 isolate(CcTest::i_isolate()),
184 scope(isolate),
185 zone(isolate),
186 T(Rep::Region(&zone, isolate), isolate) {
187 }
188
189 static void CheckEqual(TypeHandle type1, TypeHandle type2) {
190 CHECK_EQ(Rep::IsBitset(type1), Rep::IsBitset(type2));
191 CHECK_EQ(Rep::IsClass(type1), Rep::IsClass(type2));
192 CHECK_EQ(Rep::IsConstant(type1), Rep::IsConstant(type2));
193 CHECK_EQ(Rep::IsUnion(type1), Rep::IsUnion(type2));
194 CHECK_EQ(type1->NumClasses(), type2->NumClasses());
195 CHECK_EQ(type1->NumConstants(), type2->NumConstants());
196 if (Rep::IsBitset(type1)) {
197 CHECK_EQ(Rep::AsBitset(type1), Rep::AsBitset(type2));
198 } else if (Rep::IsClass(type1)) {
199 CHECK_EQ(Rep::AsClass(type1), Rep::AsClass(type2));
200 } else if (Rep::IsConstant(type1)) {
201 CHECK_EQ(Rep::AsConstant(type1), Rep::AsConstant(type2));
202 } else if (Rep::IsUnion(type1)) {
203 CHECK_EQ(Rep::AsUnion(type1)->length(), Rep::AsUnion(type2)->length());
204 }
205 CHECK(type1->Is(type2));
206 CHECK(type2->Is(type1));
207 }
208
209 static void CheckSub(TypeHandle type1, TypeHandle type2) {
210 CHECK(type1->Is(type2));
211 CHECK(!type2->Is(type1));
212 if (Rep::IsBitset(type1) && Rep::IsBitset(type2)) {
213 CHECK_NE(Rep::AsBitset(type1), Rep::AsBitset(type2));
214 }
215 }
216
217 static void CheckUnordered(TypeHandle type1, TypeHandle type2) {
218 CHECK(!type1->Is(type2));
219 CHECK(!type2->Is(type1));
220 if (Rep::IsBitset(type1) && Rep::IsBitset(type2)) {
221 CHECK_NE(Rep::AsBitset(type1), Rep::AsBitset(type2));
222 }
223 }
224
225 static void CheckOverlap(TypeHandle type1, TypeHandle type2) {
226 CHECK(type1->Maybe(type2));
227 CHECK(type2->Maybe(type1));
228 if (Rep::IsBitset(type1) && Rep::IsBitset(type2)) {
229 CHECK_NE(0, Rep::AsBitset(type1) & Rep::AsBitset(type2));
230 }
231 }
232
233 static void CheckDisjoint(TypeHandle type1, TypeHandle type2) {
234 CHECK(!type1->Is(type2));
235 CHECK(!type2->Is(type1));
236 CHECK(!type1->Maybe(type2));
237 CHECK(!type2->Maybe(type1));
238 if (Rep::IsBitset(type1) && Rep::IsBitset(type2)) {
239 CHECK_EQ(0, Rep::AsBitset(type1) & Rep::AsBitset(type2));
240 }
241 }
242
243 void Bitset() {
244 CHECK(IsBitset(T.None));
245 CHECK(IsBitset(T.Any));
246 CHECK(IsBitset(T.String));
247 CHECK(IsBitset(T.Object));
248
249 CHECK(IsBitset(T.Union(T.String, T.Number)));
250 CHECK(IsBitset(T.Union(T.String, T.Receiver)));
251
252 CHECK_EQ(0, AsBitset(T.None));
253 CHECK_EQ(AsBitset(T.Number) | AsBitset(T.String),
254 AsBitset(T.Union(T.String, T.Number)));
255 CHECK_EQ(AsBitset(T.Receiver),
256 AsBitset(T.Union(T.Receiver, T.Object)));
257 }
258
259 void Class() {
260 CHECK(IsClass(T.ObjectClass));
261 CHECK(IsClass(T.ArrayClass));
262
263 CHECK(*T.object_map == AsClass(T.ObjectClass));
264 CHECK(*T.array_map == AsClass(T.ArrayClass));
265 }
266
267 void Constant() {
268 CHECK(IsConstant(T.SmiConstant));
269 CHECK(IsConstant(T.ObjectConstant1));
270 CHECK(IsConstant(T.ObjectConstant2));
271 CHECK(IsConstant(T.ArrayConstant1));
272 CHECK(IsConstant(T.ArrayConstant2));
273
274 CHECK(*T.smi == AsConstant(T.SmiConstant));
275 CHECK(*T.object1 == AsConstant(T.ObjectConstant1));
276 CHECK(*T.object2 == AsConstant(T.ObjectConstant2));
277 CHECK(*T.object1 != AsConstant(T.ObjectConstant2));
278 CHECK(*T.array == AsConstant(T.ArrayConstant1));
279 CHECK(*T.array == AsConstant(T.ArrayConstant2));
280 }
281
282 void Is() {
283 // Reflexivity
284 CHECK(T.None->Is(T.None));
285 CHECK(T.Any->Is(T.Any));
286 CHECK(T.Object->Is(T.Object));
287
288 CHECK(T.ObjectClass->Is(T.ObjectClass));
289 CHECK(T.ObjectConstant1->Is(T.ObjectConstant1));
290 CHECK(T.ArrayConstant1->Is(T.ArrayConstant2));
291
292 // Symmetry and Transitivity
293 CheckSub(T.None, T.Number);
294 CheckSub(T.None, T.Any);
295
296 CheckSub(T.Oddball, T.Any);
297 CheckSub(T.Boolean, T.Oddball);
298 CheckSub(T.Null, T.Oddball);
299 CheckSub(T.Undefined, T.Oddball);
300 CheckUnordered(T.Boolean, T.Null);
301 CheckUnordered(T.Undefined, T.Null);
302 CheckUnordered(T.Boolean, T.Undefined);
303
304 CheckSub(T.Number, T.Any);
305 CheckSub(T.Smi, T.Number);
306 CheckSub(T.Signed32, T.Number);
307 CheckSub(T.Double, T.Number);
308 CheckSub(T.Smi, T.Signed32);
309 CheckUnordered(T.Smi, T.Double);
310 CheckUnordered(T.Signed32, T.Double);
311
312 CheckSub(T.Name, T.Any);
313 CheckSub(T.UniqueName, T.Any);
314 CheckSub(T.UniqueName, T.Name);
315 CheckSub(T.String, T.Name);
316 CheckSub(T.InternalizedString, T.String);
317 CheckSub(T.InternalizedString, T.UniqueName);
318 CheckSub(T.InternalizedString, T.Name);
319 CheckSub(T.Symbol, T.UniqueName);
320 CheckSub(T.Symbol, T.Name);
321 CheckUnordered(T.String, T.UniqueName);
322 CheckUnordered(T.String, T.Symbol);
323 CheckUnordered(T.InternalizedString, T.Symbol);
324
325 CheckSub(T.Receiver, T.Any);
326 CheckSub(T.Object, T.Any);
327 CheckSub(T.Object, T.Receiver);
328 CheckSub(T.Array, T.Object);
329 CheckSub(T.Function, T.Object);
330 CheckSub(T.Proxy, T.Receiver);
331 CheckUnordered(T.Object, T.Proxy);
332 CheckUnordered(T.Array, T.Function);
333
334 // Structured subtyping
335 CheckSub(T.None, T.ObjectClass);
336 CheckSub(T.None, T.ObjectConstant1);
337 CheckSub(T.ObjectClass, T.Any);
338 CheckSub(T.ObjectConstant1, T.Any);
339
340 CheckSub(T.ObjectClass, T.Object);
341 CheckSub(T.ArrayClass, T.Object);
342 CheckUnordered(T.ObjectClass, T.ArrayClass);
343
344 CheckSub(T.SmiConstant, T.Smi);
345 CheckSub(T.SmiConstant, T.Signed32);
346 CheckSub(T.SmiConstant, T.Number);
347 CheckSub(T.ObjectConstant1, T.Object);
348 CheckSub(T.ObjectConstant2, T.Object);
349 CheckSub(T.ArrayConstant1, T.Object);
350 CheckSub(T.ArrayConstant1, T.Array);
351 CheckUnordered(T.ObjectConstant1, T.ObjectConstant2);
352 CheckUnordered(T.ObjectConstant1, T.ArrayConstant1);
353
354 CheckUnordered(T.ObjectConstant1, T.ObjectClass);
355 CheckUnordered(T.ObjectConstant2, T.ObjectClass);
356 CheckUnordered(T.ObjectConstant1, T.ArrayClass);
357 CheckUnordered(T.ObjectConstant2, T.ArrayClass);
358 CheckUnordered(T.ArrayConstant1, T.ObjectClass);
359 }
360
361 void Maybe() {
362 CheckOverlap(T.Any, T.Any);
363 CheckOverlap(T.Object, T.Object);
364
365 CheckOverlap(T.Oddball, T.Any);
366 CheckOverlap(T.Boolean, T.Oddball);
367 CheckOverlap(T.Null, T.Oddball);
368 CheckOverlap(T.Undefined, T.Oddball);
369 CheckDisjoint(T.Boolean, T.Null);
370 CheckDisjoint(T.Undefined, T.Null);
371 CheckDisjoint(T.Boolean, T.Undefined);
372
373 CheckOverlap(T.Number, T.Any);
374 CheckOverlap(T.Smi, T.Number);
375 CheckOverlap(T.Double, T.Number);
376 CheckDisjoint(T.Signed32, T.Double);
377
378 CheckOverlap(T.Name, T.Any);
379 CheckOverlap(T.UniqueName, T.Any);
380 CheckOverlap(T.UniqueName, T.Name);
381 CheckOverlap(T.String, T.Name);
382 CheckOverlap(T.InternalizedString, T.String);
383 CheckOverlap(T.InternalizedString, T.UniqueName);
384 CheckOverlap(T.InternalizedString, T.Name);
385 CheckOverlap(T.Symbol, T.UniqueName);
386 CheckOverlap(T.Symbol, T.Name);
387 CheckOverlap(T.String, T.UniqueName);
388 CheckDisjoint(T.String, T.Symbol);
389 CheckDisjoint(T.InternalizedString, T.Symbol);
390
391 CheckOverlap(T.Receiver, T.Any);
392 CheckOverlap(T.Object, T.Any);
393 CheckOverlap(T.Object, T.Receiver);
394 CheckOverlap(T.Array, T.Object);
395 CheckOverlap(T.Function, T.Object);
396 CheckOverlap(T.Proxy, T.Receiver);
397 CheckDisjoint(T.Object, T.Proxy);
398 CheckDisjoint(T.Array, T.Function);
399
400 CheckOverlap(T.ObjectClass, T.Any);
401 CheckOverlap(T.ObjectConstant1, T.Any);
402
403 CheckOverlap(T.ObjectClass, T.Object);
404 CheckOverlap(T.ArrayClass, T.Object);
405 CheckOverlap(T.ObjectClass, T.ObjectClass);
406 CheckOverlap(T.ArrayClass, T.ArrayClass);
407 CheckDisjoint(T.ObjectClass, T.ArrayClass);
408
409 CheckOverlap(T.SmiConstant, T.Smi);
410 CheckOverlap(T.SmiConstant, T.Signed32);
411 CheckOverlap(T.SmiConstant, T.Number);
412 CheckDisjoint(T.SmiConstant, T.Double);
413 CheckOverlap(T.ObjectConstant1, T.Object);
414 CheckOverlap(T.ObjectConstant2, T.Object);
415 CheckOverlap(T.ArrayConstant1, T.Object);
416 CheckOverlap(T.ArrayConstant1, T.Array);
417 CheckOverlap(T.ArrayConstant1, T.ArrayConstant2);
418 CheckOverlap(T.ObjectConstant1, T.ObjectConstant1);
419 CheckDisjoint(T.ObjectConstant1, T.ObjectConstant2);
420 CheckDisjoint(T.ObjectConstant1, T.ArrayConstant1);
421
422 CheckDisjoint(T.ObjectConstant1, T.ObjectClass);
423 CheckDisjoint(T.ObjectConstant2, T.ObjectClass);
424 CheckDisjoint(T.ObjectConstant1, T.ArrayClass);
425 CheckDisjoint(T.ObjectConstant2, T.ArrayClass);
426 CheckDisjoint(T.ArrayConstant1, T.ObjectClass);
427 }
428
429 void Union() {
430 // Bitset-bitset
431 CHECK(IsBitset(T.Union(T.Object, T.Number)));
432 CHECK(IsBitset(T.Union(T.Object, T.Object)));
433 CHECK(IsBitset(T.Union(T.Any, T.None)));
434
435 CheckEqual(T.Union(T.None, T.Number), T.Number);
436 CheckEqual(T.Union(T.Object, T.Proxy), T.Receiver);
437 CheckEqual(T.Union(T.Number, T.String), T.Union(T.String, T.Number));
438 CheckSub(T.Union(T.Number, T.String), T.Any);
439
440 // Class-class
441 CHECK(IsClass(T.Union(T.ObjectClass, T.ObjectClass)));
442 CHECK(IsUnion(T.Union(T.ObjectClass, T.ArrayClass)));
443
444 CheckEqual(T.Union(T.ObjectClass, T.ObjectClass), T.ObjectClass);
445 CheckSub(T.None, T.Union(T.ObjectClass, T.ArrayClass));
446 CheckSub(T.Union(T.ObjectClass, T.ArrayClass), T.Any);
447 CheckSub(T.ObjectClass, T.Union(T.ObjectClass, T.ArrayClass));
448 CheckSub(T.ArrayClass, T.Union(T.ObjectClass, T.ArrayClass));
449 CheckSub(T.Union(T.ObjectClass, T.ArrayClass), T.Object);
450 CheckUnordered(T.Union(T.ObjectClass, T.ArrayClass), T.Array);
451 CheckOverlap(T.Union(T.ObjectClass, T.ArrayClass), T.Array);
452 CheckDisjoint(T.Union(T.ObjectClass, T.ArrayClass), T.Number);
453
454 // Constant-constant
455 CHECK(IsConstant(T.Union(T.ObjectConstant1, T.ObjectConstant1)));
456 CHECK(IsConstant(T.Union(T.ArrayConstant1, T.ArrayConstant1)));
457 CHECK(IsUnion(T.Union(T.ObjectConstant1, T.ObjectConstant2)));
458
459 CheckEqual(
460 T.Union(T.ObjectConstant1, T.ObjectConstant1),
461 T.ObjectConstant1);
462 CheckEqual(T.Union(T.ArrayConstant1, T.ArrayConstant1), T.ArrayConstant1);
463 CheckEqual(T.Union(T.ArrayConstant1, T.ArrayConstant1), T.ArrayConstant2);
464 CheckSub(T.None, T.Union(T.ObjectConstant1, T.ObjectConstant2));
465 CheckSub(T.Union(T.ObjectConstant1, T.ObjectConstant2), T.Any);
466 CheckSub(T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2));
467 CheckSub(T.ObjectConstant2, T.Union(T.ObjectConstant1, T.ObjectConstant2));
468 CheckSub(T.ArrayConstant2, T.Union(T.ArrayConstant1, T.ObjectConstant2));
469 CheckSub(T.Union(T.ObjectConstant1, T.ObjectConstant2), T.Object);
470 CheckUnordered(
471 T.Union(T.ObjectConstant1, T.ObjectConstant2), T.ObjectClass);
472 CheckUnordered(T.Union(T.ObjectConstant1, T.ArrayConstant1), T.Array);
473 CheckOverlap(T.Union(T.ObjectConstant1, T.ArrayConstant1), T.Array);
474 CheckOverlap(
475 T.Union(T.ObjectConstant1, T.ArrayConstant1), T.ArrayConstant2);
476 CheckDisjoint(T.Union(T.ObjectConstant1, T.ArrayConstant1), T.Number);
477 CheckDisjoint(T.Union(T.ObjectConstant1, T.ArrayConstant1), T.ObjectClass);
478
479 // Bitset-class
480 CHECK(IsBitset(T.Union(T.ObjectClass, T.Object)));
481 CHECK(IsUnion(T.Union(T.ObjectClass, T.Number)));
482
483 CheckEqual(T.Union(T.ObjectClass, T.Object), T.Object);
484 CheckSub(T.None, T.Union(T.ObjectClass, T.Number));
485 CheckSub(T.Union(T.ObjectClass, T.Number), T.Any);
486 CheckSub(T.Union(T.ObjectClass, T.Smi), T.Union(T.Object, T.Number));
487 CheckSub(T.Union(T.ObjectClass, T.Array), T.Object);
488 CheckUnordered(T.Union(T.ObjectClass, T.String), T.Array);
489 CheckOverlap(T.Union(T.ObjectClass, T.String), T.Object);
490 CheckDisjoint(T.Union(T.ObjectClass, T.String), T.Number);
491
492 // Bitset-constant
493 CHECK(IsBitset(T.Union(T.SmiConstant, T.Number)));
494 CHECK(IsBitset(T.Union(T.ObjectConstant1, T.Object)));
495 CHECK(IsUnion(T.Union(T.ObjectConstant2, T.Number)));
496
497 CheckEqual(T.Union(T.SmiConstant, T.Number), T.Number);
498 CheckEqual(T.Union(T.ObjectConstant1, T.Object), T.Object);
499 CheckSub(T.None, T.Union(T.ObjectConstant1, T.Number));
500 CheckSub(T.Union(T.ObjectConstant1, T.Number), T.Any);
501 CheckSub(
502 T.Union(T.ObjectConstant1, T.Signed32), T.Union(T.Object, T.Number));
503 CheckSub(T.Union(T.ObjectConstant1, T.Array), T.Object);
504 CheckUnordered(T.Union(T.ObjectConstant1, T.String), T.Array);
505 CheckOverlap(T.Union(T.ObjectConstant1, T.String), T.Object);
506 CheckDisjoint(T.Union(T.ObjectConstant1, T.String), T.Number);
507 CheckEqual(T.Union(T.Signed32, T.Signed32Constant), T.Signed32);
508
509 // Class-constant
510 CHECK(IsUnion(T.Union(T.ObjectConstant1, T.ObjectClass)));
511 CHECK(IsUnion(T.Union(T.ArrayClass, T.ObjectConstant2)));
512
513 CheckSub(T.None, T.Union(T.ObjectConstant1, T.ArrayClass));
514 CheckSub(T.Union(T.ObjectConstant1, T.ArrayClass), T.Any);
515 CheckSub(T.Union(T.ObjectConstant1, T.ArrayClass), T.Object);
516 CheckSub(T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ArrayClass));
517 CheckSub(T.ArrayClass, T.Union(T.ObjectConstant1, T.ArrayClass));
518 CheckUnordered(T.ObjectClass, T.Union(T.ObjectConstant1, T.ArrayClass));
519 CheckSub(
520 T.Union(T.ObjectConstant1, T.ArrayClass), T.Union(T.Array, T.Object));
521 CheckUnordered(T.Union(T.ObjectConstant1, T.ArrayClass), T.ArrayConstant1);
522 CheckDisjoint(T.Union(T.ObjectConstant1, T.ArrayClass), T.ObjectConstant2);
523 CheckDisjoint(T.Union(T.ObjectConstant1, T.ArrayClass), T.ObjectClass);
524
525 // Bitset-union
526 CHECK(IsBitset(
527 T.Union(T.Object, T.Union(T.ObjectConstant1, T.ObjectClass))));
528 CHECK(IsUnion(T.Union(T.Union(T.ArrayClass, T.ObjectConstant2), T.Number)));
529
530 CheckEqual(
531 T.Union(T.Object, T.Union(T.ObjectConstant1, T.ObjectClass)),
532 T.Object);
533 CheckEqual(
534 T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Number),
535 T.Union(T.ObjectConstant1, T.Union(T.Number, T.ArrayClass)));
536 CheckSub(
537 T.Double,
538 T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Number));
539 CheckSub(
540 T.ObjectConstant1,
541 T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Double));
542 CheckSub(
543 T.None,
544 T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Double));
545 CheckSub(
546 T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Double),
547 T.Any);
548 CheckSub(
549 T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Double),
550 T.Union(T.ObjectConstant1, T.Union(T.Number, T.ArrayClass)));
551
552 // Class-union
553 CHECK(IsUnion(
554 T.Union(T.Union(T.ArrayClass, T.ObjectConstant2), T.ArrayClass)));
555 CHECK(IsUnion(
556 T.Union(T.Union(T.ArrayClass, T.ObjectConstant2), T.ObjectClass)));
557
558 CheckEqual(
559 T.Union(T.ObjectClass, T.Union(T.ObjectConstant1, T.ObjectClass)),
560 T.Union(T.ObjectClass, T.ObjectConstant1));
561 CheckSub(
562 T.None,
563 T.Union(T.ObjectClass, T.Union(T.ObjectConstant1, T.ObjectClass)));
564 CheckSub(
565 T.Union(T.ObjectClass, T.Union(T.ObjectConstant1, T.ObjectClass)),
566 T.Any);
567 CheckSub(
568 T.Union(T.ObjectClass, T.Union(T.ObjectConstant1, T.ObjectClass)),
569 T.Object);
570 CheckEqual(
571 T.Union(T.Union(T.ArrayClass, T.ObjectConstant2), T.ArrayClass),
572 T.Union(T.ArrayClass, T.ObjectConstant2));
573
574 // Constant-union
575 CHECK(IsUnion(T.Union(
576 T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2))));
577 CHECK(IsUnion(T.Union(
578 T.Union(T.ArrayConstant1, T.ObjectClass), T.ObjectConstant1)));
579 CHECK(IsUnion(T.Union(
580 T.Union(T.ArrayConstant1, T.ObjectConstant2), T.ObjectConstant1)));
581
582 CheckEqual(
583 T.Union(
584 T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2)),
585 T.Union(T.ObjectConstant2, T.ObjectConstant1));
586 CheckEqual(
587 T.Union(
588 T.Union(T.ArrayConstant1, T.ObjectConstant2), T.ObjectConstant1),
589 T.Union(
590 T.ObjectConstant2, T.Union(T.ArrayConstant1, T.ObjectConstant1)));
591
592 // Union-union
593 CHECK(IsBitset(T.Union(
594 T.Union(T.Number, T.ArrayClass),
595 T.Union(T.Signed32, T.Array))));
596 CHECK(IsUnion(T.Union(
597 T.Union(T.Number, T.ArrayClass),
598 T.Union(T.ObjectClass, T.ArrayClass))));
599
600 CheckEqual(
601 T.Union(
602 T.Union(T.ObjectConstant2, T.ObjectConstant1),
603 T.Union(T.ObjectConstant1, T.ObjectConstant2)),
604 T.Union(T.ObjectConstant2, T.ObjectConstant1));
605 CheckEqual(
606 T.Union(
607 T.Union(T.ObjectConstant2, T.ArrayConstant1),
608 T.Union(T.ObjectConstant1, T.ArrayConstant2)),
609 T.Union(
610 T.Union(T.ObjectConstant1, T.ObjectConstant2),
611 T.ArrayConstant1));
612 CheckEqual(
613 T.Union(T.Union(T.Number, T.ArrayClass), T.Union(T.Smi, T.Array)),
614 T.Union(T.Number, T.Array));
615 }
616
617 void Intersect() {
618 // Bitset-bitset
619 CHECK(IsBitset(T.Intersect(T.Object, T.Number)));
620 CHECK(IsBitset(T.Intersect(T.Object, T.Object)));
621 CHECK(IsBitset(T.Intersect(T.Any, T.None)));
622
623 CheckEqual(T.Intersect(T.None, T.Number), T.None);
624 CheckEqual(T.Intersect(T.Object, T.Proxy), T.None);
625 CheckEqual(T.Intersect(T.Name, T.String), T.Intersect(T.String, T.Name));
626 CheckEqual(T.Intersect(T.UniqueName, T.String), T.InternalizedString);
627
628 // Class-class
629 CHECK(IsClass(T.Intersect(T.ObjectClass, T.ObjectClass)));
630 CHECK(IsBitset(T.Intersect(T.ObjectClass, T.ArrayClass)));
631
632 CheckEqual(T.Intersect(T.ObjectClass, T.ObjectClass), T.ObjectClass);
633 CheckEqual(T.Intersect(T.ObjectClass, T.ArrayClass), T.None);
634
635 // Constant-constant
636 CHECK(IsConstant(T.Intersect(T.ObjectConstant1, T.ObjectConstant1)));
637 CHECK(IsConstant(T.Intersect(T.ArrayConstant1, T.ArrayConstant2)));
638 CHECK(IsBitset(T.Intersect(T.ObjectConstant1, T.ObjectConstant2)));
639
640 CheckEqual(
641 T.Intersect(T.ObjectConstant1, T.ObjectConstant1), T.ObjectConstant1);
642 CheckEqual(
643 T.Intersect(T.ArrayConstant1, T.ArrayConstant2), T.ArrayConstant1);
644 CheckEqual(T.Intersect(T.ObjectConstant1, T.ObjectConstant2), T.None);
645
646 // Bitset-class
647 CHECK(IsClass(T.Intersect(T.ObjectClass, T.Object)));
648 CHECK(IsBitset(T.Intersect(T.ObjectClass, T.Number)));
649
650 CheckEqual(T.Intersect(T.ObjectClass, T.Object), T.ObjectClass);
651 CheckEqual(T.Intersect(T.ObjectClass, T.Array), T.None);
652 CheckEqual(T.Intersect(T.ObjectClass, T.Number), T.None);
653
654 // Bitset-constant
655 CHECK(IsBitset(T.Intersect(T.Smi, T.Number)));
656 CHECK(IsConstant(T.Intersect(T.SmiConstant, T.Number)));
657 CHECK(IsConstant(T.Intersect(T.ObjectConstant1, T.Object)));
658
659 CheckEqual(T.Intersect(T.Smi, T.Number), T.Smi);
660 CheckEqual(T.Intersect(T.SmiConstant, T.Number), T.SmiConstant);
661 CheckEqual(T.Intersect(T.ObjectConstant1, T.Object), T.ObjectConstant1);
662
663 // Class-constant
664 CHECK(IsBitset(T.Intersect(T.ObjectConstant1, T.ObjectClass)));
665 CHECK(IsBitset(T.Intersect(T.ArrayClass, T.ObjectConstant2)));
666
667 CheckEqual(T.Intersect(T.ObjectConstant1, T.ObjectClass), T.None);
668 CheckEqual(T.Intersect(T.ArrayClass, T.ObjectConstant2), T.None);
669
670 // Bitset-union
671 CHECK(IsUnion(
672 T.Intersect(T.Object, T.Union(T.ObjectConstant1, T.ObjectClass))));
673 CHECK(IsBitset(
674 T.Intersect(T.Union(T.ArrayClass, T.ObjectConstant2), T.Number)));
675
676 CheckEqual(
677 T.Intersect(T.Object, T.Union(T.ObjectConstant1, T.ObjectClass)),
678 T.Union(T.ObjectConstant1, T.ObjectClass));
679 CheckEqual(
680 T.Intersect(T.Union(T.ArrayClass, T.ObjectConstant1), T.Number),
681 T.None);
682
683 // Class-union
684 CHECK(IsClass(
685 T.Intersect(T.Union(T.ArrayClass, T.ObjectConstant2), T.ArrayClass)));
686 CHECK(IsClass(
687 T.Intersect(T.Union(T.Object, T.SmiConstant), T.ArrayClass)));
688 CHECK(IsBitset(
689 T.Intersect(T.Union(T.ObjectClass, T.ArrayConstant1), T.ArrayClass)));
690
691 CheckEqual(
692 T.Intersect(T.ArrayClass, T.Union(T.ObjectConstant2, T.ArrayClass)),
693 T.ArrayClass);
694 CheckEqual(
695 T.Intersect(T.ArrayClass, T.Union(T.Object, T.SmiConstant)),
696 T.ArrayClass);
697 CheckEqual(
698 T.Intersect(T.Union(T.ObjectClass, T.ArrayConstant1), T.ArrayClass),
699 T.None);
700
701 // Constant-union
702 CHECK(IsConstant(T.Intersect(
703 T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2))));
704 CHECK(IsConstant(T.Intersect(
705 T.Union(T.Number, T.ObjectClass), T.SmiConstant)));
706 CHECK(IsBitset(T.Intersect(
707 T.Union(T.ArrayConstant1, T.ObjectClass), T.ObjectConstant1)));
708
709 CheckEqual(
710 T.Intersect(
711 T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2)),
712 T.ObjectConstant1);
713 CheckEqual(
714 T.Intersect(T.SmiConstant, T.Union(T.Number, T.ObjectConstant2)),
715 T.SmiConstant);
716 CheckEqual(
717 T.Intersect(
718 T.Union(T.ArrayConstant1, T.ObjectClass), T.ObjectConstant1),
719 T.None);
720
721 // Union-union
722 CHECK(IsUnion(T.Intersect(
723 T.Union(T.Number, T.ArrayClass), T.Union(T.Signed32, T.Array))));
724 CHECK(IsBitset(T.Intersect(
725 T.Union(T.Number, T.ObjectClass), T.Union(T.Signed32, T.Array))));
726
727 CheckEqual(
728 T.Intersect(
729 T.Union(T.Number, T.ArrayClass),
730 T.Union(T.Smi, T.Array)),
731 T.Union(T.Smi, T.ArrayClass));
732 CheckEqual(
733 T.Intersect(
734 T.Union(T.Number, T.ObjectClass),
735 T.Union(T.Signed32, T.Array)),
736 T.Signed32);
737 CheckEqual(
738 T.Intersect(
739 T.Union(T.ObjectConstant2, T.ObjectConstant1),
740 T.Union(T.ObjectConstant1, T.ObjectConstant2)),
741 T.Union(T.ObjectConstant2, T.ObjectConstant1));
742 CheckEqual(
743 T.Intersect(
744 T.Union(
745 T.Union(T.ObjectConstant2, T.ObjectConstant1), T.ArrayClass),
746 T.Union(
747 T.ObjectConstant1,
748 T.Union(T.ArrayConstant1, T.ObjectConstant2))),
749 T.Union(T.ObjectConstant2, T.ObjectConstant1));
750 CheckEqual(
751 T.Intersect(
752 T.Union(T.ObjectConstant2, T.ArrayConstant1),
753 T.Union(T.ObjectConstant1, T.ArrayConstant2)),
754 T.ArrayConstant1);
755 }
756 };
757
758 typedef Tests<ZoneType, ZoneType*, Zone, ZoneRep> ZoneTests;
759 typedef Tests<Type, Handle<Type>, Isolate, HeapRep> HeapTests;
760
761
762 TEST(Bitset) { 197 TEST(Bitset) {
763 CcTest::InitializeVM(); 198 CcTest::InitializeVM();
764 ZoneTests().Bitset(); 199 Isolate* isolate = CcTest::i_isolate();
765 HeapTests().Bitset(); 200 HandleScope scope(isolate);
201 HandlifiedTypes T(isolate);
202
203 CHECK(IsBitset(T.None));
204 CHECK(IsBitset(T.Any));
205 CHECK(IsBitset(T.String));
206 CHECK(IsBitset(T.Object));
207
208 CHECK(IsBitset(T.Union(T.String, T.Number)));
209 CHECK(IsBitset(T.Union(T.String, T.Receiver)));
210
211 CHECK_EQ(0, AsBitset(T.None));
212 CHECK_EQ(AsBitset(T.Number) | AsBitset(T.String),
213 AsBitset(T.Union(T.String, T.Number)));
214 CHECK_EQ(AsBitset(T.Receiver),
215 AsBitset(T.Union(T.Receiver, T.Object)));
766 } 216 }
767 217
768 218
769 TEST(Class) { 219 TEST(Class) {
770 CcTest::InitializeVM(); 220 CcTest::InitializeVM();
771 ZoneTests().Class(); 221 Isolate* isolate = CcTest::i_isolate();
772 HeapTests().Class(); 222 HandleScope scope(isolate);
223 HandlifiedTypes T(isolate);
224
225 CHECK(IsClass(T.ObjectClass));
226 CHECK(IsClass(T.ArrayClass));
227
228 CHECK(*T.object_map == AsClass(T.ObjectClass));
229 CHECK(*T.array_map == AsClass(T.ArrayClass));
773 } 230 }
774 231
775 232
776 TEST(Constant) { 233 TEST(Constant) {
777 CcTest::InitializeVM(); 234 CcTest::InitializeVM();
778 ZoneTests().Constant(); 235 Isolate* isolate = CcTest::i_isolate();
779 HeapTests().Constant(); 236 HandleScope scope(isolate);
237 HandlifiedTypes T(isolate);
238
239 CHECK(IsConstant(T.SmiConstant));
240 CHECK(IsConstant(T.ObjectConstant1));
241 CHECK(IsConstant(T.ObjectConstant2));
242 CHECK(IsConstant(T.ArrayConstant1));
243 CHECK(IsConstant(T.ArrayConstant2));
244
245 CHECK(*T.smi == AsConstant(T.SmiConstant));
246 CHECK(*T.object1 == AsConstant(T.ObjectConstant1));
247 CHECK(*T.object2 == AsConstant(T.ObjectConstant2));
248 CHECK(*T.object1 != AsConstant(T.ObjectConstant2));
249 CHECK(*T.array == AsConstant(T.ArrayConstant1));
250 CHECK(*T.array == AsConstant(T.ArrayConstant2));
780 } 251 }
781 252
782 253
783 TEST(Is) { 254 TEST(Is) {
784 CcTest::InitializeVM(); 255 CcTest::InitializeVM();
785 ZoneTests().Is(); 256 Isolate* isolate = CcTest::i_isolate();
786 HeapTests().Is(); 257 HandleScope scope(isolate);
258 HandlifiedTypes T(isolate);
259
260 // Reflexivity
261 CHECK(T.None->Is(T.None));
262 CHECK(T.Any->Is(T.Any));
263 CHECK(T.Object->Is(T.Object));
264
265 CHECK(T.ObjectClass->Is(T.ObjectClass));
266 CHECK(T.ObjectConstant1->Is(T.ObjectConstant1));
267 CHECK(T.ArrayConstant1->Is(T.ArrayConstant2));
268
269 // Symmetry and Transitivity
270 CheckSub(T.None, T.Number);
271 CheckSub(T.None, T.Any);
272
273 CheckSub(T.Oddball, T.Any);
274 CheckSub(T.Boolean, T.Oddball);
275 CheckSub(T.Null, T.Oddball);
276 CheckSub(T.Undefined, T.Oddball);
277 CheckUnordered(T.Boolean, T.Null);
278 CheckUnordered(T.Undefined, T.Null);
279 CheckUnordered(T.Boolean, T.Undefined);
280
281 CheckSub(T.Number, T.Any);
282 CheckSub(T.Smi, T.Number);
283 CheckSub(T.Signed32, T.Number);
284 CheckSub(T.Double, T.Number);
285 CheckSub(T.Smi, T.Signed32);
286 CheckUnordered(T.Smi, T.Double);
287 CheckUnordered(T.Signed32, T.Double);
288
289 CheckSub(T.Name, T.Any);
290 CheckSub(T.UniqueName, T.Any);
291 CheckSub(T.UniqueName, T.Name);
292 CheckSub(T.String, T.Name);
293 CheckSub(T.InternalizedString, T.String);
294 CheckSub(T.InternalizedString, T.UniqueName);
295 CheckSub(T.InternalizedString, T.Name);
296 CheckSub(T.Symbol, T.UniqueName);
297 CheckSub(T.Symbol, T.Name);
298 CheckUnordered(T.String, T.UniqueName);
299 CheckUnordered(T.String, T.Symbol);
300 CheckUnordered(T.InternalizedString, T.Symbol);
301
302 CheckSub(T.Receiver, T.Any);
303 CheckSub(T.Object, T.Any);
304 CheckSub(T.Object, T.Receiver);
305 CheckSub(T.Array, T.Object);
306 CheckSub(T.Function, T.Object);
307 CheckSub(T.Proxy, T.Receiver);
308 CheckUnordered(T.Object, T.Proxy);
309 CheckUnordered(T.Array, T.Function);
310
311 // Structured subtyping
312 CheckSub(T.None, T.ObjectClass);
313 CheckSub(T.None, T.ObjectConstant1);
314 CheckSub(T.ObjectClass, T.Any);
315 CheckSub(T.ObjectConstant1, T.Any);
316
317 CheckSub(T.ObjectClass, T.Object);
318 CheckSub(T.ArrayClass, T.Object);
319 CheckUnordered(T.ObjectClass, T.ArrayClass);
320
321 CheckSub(T.SmiConstant, T.Smi);
322 CheckSub(T.SmiConstant, T.Signed32);
323 CheckSub(T.SmiConstant, T.Number);
324 CheckSub(T.ObjectConstant1, T.Object);
325 CheckSub(T.ObjectConstant2, T.Object);
326 CheckSub(T.ArrayConstant1, T.Object);
327 CheckSub(T.ArrayConstant1, T.Array);
328 CheckUnordered(T.ObjectConstant1, T.ObjectConstant2);
329 CheckUnordered(T.ObjectConstant1, T.ArrayConstant1);
330
331 CheckUnordered(T.ObjectConstant1, T.ObjectClass);
332 CheckUnordered(T.ObjectConstant2, T.ObjectClass);
333 CheckUnordered(T.ObjectConstant1, T.ArrayClass);
334 CheckUnordered(T.ObjectConstant2, T.ArrayClass);
335 CheckUnordered(T.ArrayConstant1, T.ObjectClass);
787 } 336 }
788 337
789 338
790 TEST(Maybe) { 339 TEST(Maybe) {
791 CcTest::InitializeVM(); 340 CcTest::InitializeVM();
792 ZoneTests().Maybe(); 341 Isolate* isolate = CcTest::i_isolate();
793 HeapTests().Maybe(); 342 HandleScope scope(isolate);
343 HandlifiedTypes T(isolate);
344
345 CheckOverlap(T.Any, T.Any);
346 CheckOverlap(T.Object, T.Object);
347
348 CheckOverlap(T.Oddball, T.Any);
349 CheckOverlap(T.Boolean, T.Oddball);
350 CheckOverlap(T.Null, T.Oddball);
351 CheckOverlap(T.Undefined, T.Oddball);
352 CheckDisjoint(T.Boolean, T.Null);
353 CheckDisjoint(T.Undefined, T.Null);
354 CheckDisjoint(T.Boolean, T.Undefined);
355
356 CheckOverlap(T.Number, T.Any);
357 CheckOverlap(T.Smi, T.Number);
358 CheckOverlap(T.Double, T.Number);
359 CheckDisjoint(T.Signed32, T.Double);
360
361 CheckOverlap(T.Name, T.Any);
362 CheckOverlap(T.UniqueName, T.Any);
363 CheckOverlap(T.UniqueName, T.Name);
364 CheckOverlap(T.String, T.Name);
365 CheckOverlap(T.InternalizedString, T.String);
366 CheckOverlap(T.InternalizedString, T.UniqueName);
367 CheckOverlap(T.InternalizedString, T.Name);
368 CheckOverlap(T.Symbol, T.UniqueName);
369 CheckOverlap(T.Symbol, T.Name);
370 CheckOverlap(T.String, T.UniqueName);
371 CheckDisjoint(T.String, T.Symbol);
372 CheckDisjoint(T.InternalizedString, T.Symbol);
373
374 CheckOverlap(T.Receiver, T.Any);
375 CheckOverlap(T.Object, T.Any);
376 CheckOverlap(T.Object, T.Receiver);
377 CheckOverlap(T.Array, T.Object);
378 CheckOverlap(T.Function, T.Object);
379 CheckOverlap(T.Proxy, T.Receiver);
380 CheckDisjoint(T.Object, T.Proxy);
381 CheckDisjoint(T.Array, T.Function);
382
383 CheckOverlap(T.ObjectClass, T.Any);
384 CheckOverlap(T.ObjectConstant1, T.Any);
385
386 CheckOverlap(T.ObjectClass, T.Object);
387 CheckOverlap(T.ArrayClass, T.Object);
388 CheckOverlap(T.ObjectClass, T.ObjectClass);
389 CheckOverlap(T.ArrayClass, T.ArrayClass);
390 CheckDisjoint(T.ObjectClass, T.ArrayClass);
391
392 CheckOverlap(T.SmiConstant, T.Smi);
393 CheckOverlap(T.SmiConstant, T.Signed32);
394 CheckOverlap(T.SmiConstant, T.Number);
395 CheckDisjoint(T.SmiConstant, T.Double);
396 CheckOverlap(T.ObjectConstant1, T.Object);
397 CheckOverlap(T.ObjectConstant2, T.Object);
398 CheckOverlap(T.ArrayConstant1, T.Object);
399 CheckOverlap(T.ArrayConstant1, T.Array);
400 CheckOverlap(T.ArrayConstant1, T.ArrayConstant2);
401 CheckOverlap(T.ObjectConstant1, T.ObjectConstant1);
402 CheckDisjoint(T.ObjectConstant1, T.ObjectConstant2);
403 CheckDisjoint(T.ObjectConstant1, T.ArrayConstant1);
404
405 CheckDisjoint(T.ObjectConstant1, T.ObjectClass);
406 CheckDisjoint(T.ObjectConstant2, T.ObjectClass);
407 CheckDisjoint(T.ObjectConstant1, T.ArrayClass);
408 CheckDisjoint(T.ObjectConstant2, T.ArrayClass);
409 CheckDisjoint(T.ArrayConstant1, T.ObjectClass);
794 } 410 }
795 411
796 412
797 TEST(Union) { 413 TEST(Union) {
798 CcTest::InitializeVM(); 414 CcTest::InitializeVM();
799 ZoneTests().Union(); 415 Isolate* isolate = CcTest::i_isolate();
800 HeapTests().Union(); 416 HandleScope scope(isolate);
417 HandlifiedTypes T(isolate);
418
419 // Bitset-bitset
420 CHECK(IsBitset(T.Union(T.Object, T.Number)));
421 CHECK(IsBitset(T.Union(T.Object, T.Object)));
422 CHECK(IsBitset(T.Union(T.Any, T.None)));
423
424 CheckEqual(T.Union(T.None, T.Number), T.Number);
425 CheckEqual(T.Union(T.Object, T.Proxy), T.Receiver);
426 CheckEqual(T.Union(T.Number, T.String), T.Union(T.String, T.Number));
427 CheckSub(T.Union(T.Number, T.String), T.Any);
428
429 // Class-class
430 CHECK(IsClass(T.Union(T.ObjectClass, T.ObjectClass)));
431 CHECK(IsUnion(T.Union(T.ObjectClass, T.ArrayClass)));
432
433 CheckEqual(T.Union(T.ObjectClass, T.ObjectClass), T.ObjectClass);
434 CheckSub(T.None, T.Union(T.ObjectClass, T.ArrayClass));
435 CheckSub(T.Union(T.ObjectClass, T.ArrayClass), T.Any);
436 CheckSub(T.ObjectClass, T.Union(T.ObjectClass, T.ArrayClass));
437 CheckSub(T.ArrayClass, T.Union(T.ObjectClass, T.ArrayClass));
438 CheckSub(T.Union(T.ObjectClass, T.ArrayClass), T.Object);
439 CheckUnordered(T.Union(T.ObjectClass, T.ArrayClass), T.Array);
440 CheckOverlap(T.Union(T.ObjectClass, T.ArrayClass), T.Array);
441 CheckDisjoint(T.Union(T.ObjectClass, T.ArrayClass), T.Number);
442
443 // Constant-constant
444 CHECK(IsConstant(T.Union(T.ObjectConstant1, T.ObjectConstant1)));
445 CHECK(IsConstant(T.Union(T.ArrayConstant1, T.ArrayConstant1)));
446 CHECK(IsUnion(T.Union(T.ObjectConstant1, T.ObjectConstant2)));
447
448 CheckEqual(T.Union(T.ObjectConstant1, T.ObjectConstant1), T.ObjectConstant1);
449 CheckEqual(T.Union(T.ArrayConstant1, T.ArrayConstant1), T.ArrayConstant1);
450 CheckEqual(T.Union(T.ArrayConstant1, T.ArrayConstant1), T.ArrayConstant2);
451 CheckSub(T.None, T.Union(T.ObjectConstant1, T.ObjectConstant2));
452 CheckSub(T.Union(T.ObjectConstant1, T.ObjectConstant2), T.Any);
453 CheckSub(T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2));
454 CheckSub(T.ObjectConstant2, T.Union(T.ObjectConstant1, T.ObjectConstant2));
455 CheckSub(T.ArrayConstant2, T.Union(T.ArrayConstant1, T.ObjectConstant2));
456 CheckSub(T.Union(T.ObjectConstant1, T.ObjectConstant2), T.Object);
457 CheckUnordered(T.Union(T.ObjectConstant1, T.ObjectConstant2), T.ObjectClass);
458 CheckUnordered(T.Union(T.ObjectConstant1, T.ArrayConstant1), T.Array);
459 CheckOverlap(T.Union(T.ObjectConstant1, T.ArrayConstant1), T.Array);
460 CheckOverlap(T.Union(T.ObjectConstant1, T.ArrayConstant1), T.ArrayConstant2);
461 CheckDisjoint(T.Union(T.ObjectConstant1, T.ArrayConstant1), T.Number);
462 CheckDisjoint(T.Union(T.ObjectConstant1, T.ArrayConstant1), T.ObjectClass);
463
464 // Bitset-class
465 CHECK(IsBitset(T.Union(T.ObjectClass, T.Object)));
466 CHECK(IsUnion(T.Union(T.ObjectClass, T.Number)));
467
468 CheckEqual(T.Union(T.ObjectClass, T.Object), T.Object);
469 CheckSub(T.None, T.Union(T.ObjectClass, T.Number));
470 CheckSub(T.Union(T.ObjectClass, T.Number), T.Any);
471 CheckSub(T.Union(T.ObjectClass, T.Smi), T.Union(T.Object, T.Number));
472 CheckSub(T.Union(T.ObjectClass, T.Array), T.Object);
473 CheckUnordered(T.Union(T.ObjectClass, T.String), T.Array);
474 CheckOverlap(T.Union(T.ObjectClass, T.String), T.Object);
475 CheckDisjoint(T.Union(T.ObjectClass, T.String), T.Number);
476
477 // Bitset-constant
478 CHECK(IsBitset(T.Union(T.SmiConstant, T.Number)));
479 CHECK(IsBitset(T.Union(T.ObjectConstant1, T.Object)));
480 CHECK(IsUnion(T.Union(T.ObjectConstant2, T.Number)));
481
482 CheckEqual(T.Union(T.SmiConstant, T.Number), T.Number);
483 CheckEqual(T.Union(T.ObjectConstant1, T.Object), T.Object);
484 CheckSub(T.None, T.Union(T.ObjectConstant1, T.Number));
485 CheckSub(T.Union(T.ObjectConstant1, T.Number), T.Any);
486 CheckSub(T.Union(T.ObjectConstant1, T.Signed32), T.Union(T.Object, T.Number));
487 CheckSub(T.Union(T.ObjectConstant1, T.Array), T.Object);
488 CheckUnordered(T.Union(T.ObjectConstant1, T.String), T.Array);
489 CheckOverlap(T.Union(T.ObjectConstant1, T.String), T.Object);
490 CheckDisjoint(T.Union(T.ObjectConstant1, T.String), T.Number);
491 CheckEqual(T.Union(T.Signed32, T.Signed32Constant), T.Signed32);
492
493 // Class-constant
494 CHECK(IsUnion(T.Union(T.ObjectConstant1, T.ObjectClass)));
495 CHECK(IsUnion(T.Union(T.ArrayClass, T.ObjectConstant2)));
496
497 CheckSub(T.None, T.Union(T.ObjectConstant1, T.ArrayClass));
498 CheckSub(T.Union(T.ObjectConstant1, T.ArrayClass), T.Any);
499 CheckSub(T.Union(T.ObjectConstant1, T.ArrayClass), T.Object);
500 CheckSub(T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ArrayClass));
501 CheckSub(T.ArrayClass, T.Union(T.ObjectConstant1, T.ArrayClass));
502 CheckUnordered(T.ObjectClass, T.Union(T.ObjectConstant1, T.ArrayClass));
503 CheckSub(
504 T.Union(T.ObjectConstant1, T.ArrayClass), T.Union(T.Array, T.Object));
505 CheckUnordered(T.Union(T.ObjectConstant1, T.ArrayClass), T.ArrayConstant1);
506 CheckDisjoint(T.Union(T.ObjectConstant1, T.ArrayClass), T.ObjectConstant2);
507 CheckDisjoint(T.Union(T.ObjectConstant1, T.ArrayClass), T.ObjectClass);
508
509 // Bitset-union
510 CHECK(IsBitset(T.Union(T.Object, T.Union(T.ObjectConstant1, T.ObjectClass))));
511 CHECK(IsUnion(T.Union(T.Union(T.ArrayClass, T.ObjectConstant2), T.Number)));
512
513 CheckEqual(
514 T.Union(T.Object, T.Union(T.ObjectConstant1, T.ObjectClass)),
515 T.Object);
516 CheckEqual(
517 T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Number),
518 T.Union(T.ObjectConstant1, T.Union(T.Number, T.ArrayClass)));
519 CheckSub(
520 T.Double,
521 T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Number));
522 CheckSub(
523 T.ObjectConstant1,
524 T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Double));
525 CheckSub(
526 T.None,
527 T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Double));
528 CheckSub(
529 T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Double),
530 T.Any);
531 CheckSub(
532 T.Union(T.Union(T.ArrayClass, T.ObjectConstant1), T.Double),
533 T.Union(T.ObjectConstant1, T.Union(T.Number, T.ArrayClass)));
534
535 // Class-union
536 CHECK(IsUnion(
537 T.Union(T.Union(T.ArrayClass, T.ObjectConstant2), T.ArrayClass)));
538 CHECK(IsUnion(
539 T.Union(T.Union(T.ArrayClass, T.ObjectConstant2), T.ObjectClass)));
540
541 CheckEqual(
542 T.Union(T.ObjectClass, T.Union(T.ObjectConstant1, T.ObjectClass)),
543 T.Union(T.ObjectClass, T.ObjectConstant1));
544 CheckSub(
545 T.None,
546 T.Union(T.ObjectClass, T.Union(T.ObjectConstant1, T.ObjectClass)));
547 CheckSub(
548 T.Union(T.ObjectClass, T.Union(T.ObjectConstant1, T.ObjectClass)),
549 T.Any);
550 CheckSub(
551 T.Union(T.ObjectClass, T.Union(T.ObjectConstant1, T.ObjectClass)),
552 T.Object);
553 CheckEqual(
554 T.Union(T.Union(T.ArrayClass, T.ObjectConstant2), T.ArrayClass),
555 T.Union(T.ArrayClass, T.ObjectConstant2));
556
557 // Constant-union
558 CHECK(IsUnion(T.Union(
559 T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2))));
560 CHECK(IsUnion(T.Union(
561 T.Union(T.ArrayConstant1, T.ObjectClass), T.ObjectConstant1)));
562 CHECK(IsUnion(T.Union(
563 T.Union(T.ArrayConstant1, T.ObjectConstant2), T.ObjectConstant1)));
564
565 CheckEqual(
566 T.Union(T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2)),
567 T.Union(T.ObjectConstant2, T.ObjectConstant1));
568 CheckEqual(
569 T.Union(T.Union(T.ArrayConstant1, T.ObjectConstant2), T.ObjectConstant1),
570 T.Union(T.ObjectConstant2, T.Union(T.ArrayConstant1, T.ObjectConstant1)));
571
572 // Union-union
573 CHECK(IsBitset(T.Union(
574 T.Union(T.Number, T.ArrayClass), T.Union(T.Signed32, T.Array))));
575 CHECK(IsUnion(T.Union(
576 T.Union(T.Number, T.ArrayClass), T.Union(T.ObjectClass, T.ArrayClass))));
577
578 CheckEqual(
579 T.Union(
580 T.Union(T.ObjectConstant2, T.ObjectConstant1),
581 T.Union(T.ObjectConstant1, T.ObjectConstant2)),
582 T.Union(T.ObjectConstant2, T.ObjectConstant1));
583 CheckEqual(
584 T.Union(
585 T.Union(T.ObjectConstant2, T.ArrayConstant1),
586 T.Union(T.ObjectConstant1, T.ArrayConstant2)),
587 T.Union(T.Union(T.ObjectConstant1, T.ObjectConstant2), T.ArrayConstant1));
588 CheckEqual(
589 T.Union(T.Union(T.Number, T.ArrayClass), T.Union(T.Smi, T.Array)),
590 T.Union(T.Number, T.Array));
801 } 591 }
802 592
803 593
804 TEST(Intersect) { 594 TEST(Intersect) {
805 CcTest::InitializeVM(); 595 CcTest::InitializeVM();
806 ZoneTests().Intersect(); 596 Isolate* isolate = CcTest::i_isolate();
807 HeapTests().Intersect(); 597 HandleScope scope(isolate);
808 } 598 HandlifiedTypes T(isolate);
599
600 // Bitset-bitset
601 CHECK(IsBitset(T.Intersect(T.Object, T.Number)));
602 CHECK(IsBitset(T.Intersect(T.Object, T.Object)));
603 CHECK(IsBitset(T.Intersect(T.Any, T.None)));
604
605 CheckEqual(T.Intersect(T.None, T.Number), T.None);
606 CheckEqual(T.Intersect(T.Object, T.Proxy), T.None);
607 CheckEqual(T.Intersect(T.Name, T.String), T.Intersect(T.String, T.Name));
608 CheckEqual(T.Intersect(T.UniqueName, T.String), T.InternalizedString);
609
610 // Class-class
611 CHECK(IsClass(T.Intersect(T.ObjectClass, T.ObjectClass)));
612 CHECK(IsBitset(T.Intersect(T.ObjectClass, T.ArrayClass)));
613
614 CheckEqual(T.Intersect(T.ObjectClass, T.ObjectClass), T.ObjectClass);
615 CheckEqual(T.Intersect(T.ObjectClass, T.ArrayClass), T.None);
616
617 // Constant-constant
618 CHECK(IsConstant(T.Intersect(T.ObjectConstant1, T.ObjectConstant1)));
619 CHECK(IsConstant(T.Intersect(T.ArrayConstant1, T.ArrayConstant2)));
620 CHECK(IsBitset(T.Intersect(T.ObjectConstant1, T.ObjectConstant2)));
621
622 CheckEqual(
623 T.Intersect(T.ObjectConstant1, T.ObjectConstant1), T.ObjectConstant1);
624 CheckEqual(
625 T.Intersect(T.ArrayConstant1, T.ArrayConstant2), T.ArrayConstant1);
626 CheckEqual(T.Intersect(T.ObjectConstant1, T.ObjectConstant2), T.None);
627
628 // Bitset-class
629 CHECK(IsClass(T.Intersect(T.ObjectClass, T.Object)));
630 CHECK(IsBitset(T.Intersect(T.ObjectClass, T.Number)));
631
632 CheckEqual(T.Intersect(T.ObjectClass, T.Object), T.ObjectClass);
633 CheckEqual(T.Intersect(T.ObjectClass, T.Array), T.None);
634 CheckEqual(T.Intersect(T.ObjectClass, T.Number), T.None);
635
636 // Bitset-constant
637 CHECK(IsBitset(T.Intersect(T.Smi, T.Number)));
638 CHECK(IsConstant(T.Intersect(T.SmiConstant, T.Number)));
639 CHECK(IsConstant(T.Intersect(T.ObjectConstant1, T.Object)));
640
641 CheckEqual(T.Intersect(T.Smi, T.Number), T.Smi);
642 CheckEqual(T.Intersect(T.SmiConstant, T.Number), T.SmiConstant);
643 CheckEqual(T.Intersect(T.ObjectConstant1, T.Object), T.ObjectConstant1);
644
645 // Class-constant
646 CHECK(IsBitset(T.Intersect(T.ObjectConstant1, T.ObjectClass)));
647 CHECK(IsBitset(T.Intersect(T.ArrayClass, T.ObjectConstant2)));
648
649 CheckEqual(T.Intersect(T.ObjectConstant1, T.ObjectClass), T.None);
650 CheckEqual(T.Intersect(T.ArrayClass, T.ObjectConstant2), T.None);
651
652 // Bitset-union
653 CHECK(IsUnion(
654 T.Intersect(T.Object, T.Union(T.ObjectConstant1, T.ObjectClass))));
655 CHECK(IsBitset(
656 T.Intersect(T.Union(T.ArrayClass, T.ObjectConstant2), T.Number)));
657
658 CheckEqual(
659 T.Intersect(T.Object, T.Union(T.ObjectConstant1, T.ObjectClass)),
660 T.Union(T.ObjectConstant1, T.ObjectClass));
661 CheckEqual(
662 T.Intersect(T.Union(T.ArrayClass, T.ObjectConstant1), T.Number),
663 T.None);
664
665 // Class-union
666 CHECK(IsClass(
667 T.Intersect(T.Union(T.ArrayClass, T.ObjectConstant2), T.ArrayClass)));
668 CHECK(IsClass(
669 T.Intersect(T.Union(T.Object, T.SmiConstant), T.ArrayClass)));
670 CHECK(IsBitset(
671 T.Intersect(T.Union(T.ObjectClass, T.ArrayConstant1), T.ArrayClass)));
672
673 CheckEqual(
674 T.Intersect(T.ArrayClass, T.Union(T.ObjectConstant2, T.ArrayClass)),
675 T.ArrayClass);
676 CheckEqual(
677 T.Intersect(T.ArrayClass, T.Union(T.Object, T.SmiConstant)),
678 T.ArrayClass);
679 CheckEqual(
680 T.Intersect(T.Union(T.ObjectClass, T.ArrayConstant1), T.ArrayClass),
681 T.None);
682
683 // Constant-union
684 CHECK(IsConstant(T.Intersect(
685 T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2))));
686 CHECK(IsConstant(T.Intersect(
687 T.Union(T.Number, T.ObjectClass), T.SmiConstant)));
688 CHECK(IsBitset(T.Intersect(
689 T.Union(T.ArrayConstant1, T.ObjectClass), T.ObjectConstant1)));
690
691 CheckEqual(
692 T.Intersect(
693 T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2)),
694 T.ObjectConstant1);
695 CheckEqual(
696 T.Intersect(T.SmiConstant, T.Union(T.Number, T.ObjectConstant2)),
697 T.SmiConstant);
698 CheckEqual(
699 T.Intersect(T.Union(T.ArrayConstant1, T.ObjectClass), T.ObjectConstant1),
700 T.None);
701
702 // Union-union
703 CHECK(IsUnion(T.Intersect(
704 T.Union(T.Number, T.ArrayClass), T.Union(T.Signed32, T.Array))));
705 CHECK(IsBitset(T.Intersect(
706 T.Union(T.Number, T.ObjectClass), T.Union(T.Signed32, T.Array))));
707
708 CheckEqual(
709 T.Intersect(
710 T.Union(T.Number, T.ArrayClass),
711 T.Union(T.Smi, T.Array)),
712 T.Union(T.Smi, T.ArrayClass));
713 CheckEqual(
714 T.Intersect(
715 T.Union(T.Number, T.ObjectClass),
716 T.Union(T.Signed32, T.Array)),
717 T.Signed32);
718 CheckEqual(
719 T.Intersect(
720 T.Union(T.ObjectConstant2, T.ObjectConstant1),
721 T.Union(T.ObjectConstant1, T.ObjectConstant2)),
722 T.Union(T.ObjectConstant2, T.ObjectConstant1));
723 CheckEqual(
724 T.Intersect(
725 T.Union(T.Union(T.ObjectConstant2, T.ObjectConstant1), T.ArrayClass),
726 T.Union(
727 T.ObjectConstant1, T.Union(T.ArrayConstant1, T.ObjectConstant2))),
728 T.Union(T.ObjectConstant2, T.ObjectConstant1));
729 CheckEqual(
730 T.Intersect(
731 T.Union(T.ObjectConstant2, T.ArrayConstant1),
732 T.Union(T.ObjectConstant1, T.ArrayConstant2)),
733 T.ArrayConstant1);
734 }
OLDNEW
« no previous file with comments | « src/types.cc ('k') | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698