Fix symmetry of Maybe() predicate. Fix bug in NowContains() predicate.

test/cctest/test-types.cc

 // Copyright 2013 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
 //       with the distribution.
 //     * Neither the name of Google Inc. nor the names of its
 //       contributors may be used to endorse or promote products derived
 //       from this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (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 <list>
+#include <vector>
 
 #include "cctest.h"
 #include "types.h"
 #include "utils/random-number-generator.h"
 
 using namespace v8::internal;
 
 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)),
-      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) {
+    static const size_t kMaxTypes = 300;
+    types.reserve(kMaxTypes);
+
+    #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);
+    types.push_back(ObjectClass);
+    types.push_back(ArrayClass);
+
     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);
+    values.push_back(smi);
+    values.push_back(signed32);
+    values.push_back(object1);
+    values.push_back(object2);
+    values.push_back(array);
     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);
-
-    types.push_back(None);
-    types.push_back(Any);
-    types.push_back(Boolean);
-    types.push_back(Null);
-    types.push_back(Undefined);
-    types.push_back(Number);
-    types.push_back(SignedSmall);
-    types.push_back(Signed32);
-    types.push_back(Float);
-    types.push_back(Name);
-    types.push_back(UniqueName);
-    types.push_back(String);
-    types.push_back(InternalizedString);
-    types.push_back(Symbol);
-    types.push_back(Receiver);
-    types.push_back(Object);
-    types.push_back(Array);
-    types.push_back(Function);
-    types.push_back(Proxy);
-    types.push_back(ObjectClass);
-    types.push_back(ArrayClass);
-    types.push_back(SmiConstant);
-    types.push_back(Signed32Constant);
-    types.push_back(ObjectConstant1);
-    types.push_back(ObjectConstant2);
-    types.push_back(ArrayConstant1);
-    types.push_back(ArrayConstant2);
-    for (int i = 0; i < 300; ++i) {
-      types.push_back(Fuzz());
+    ArrayConstant = Type::Constant(array, region);
+    for (ValueVector::iterator it = values.begin(); it != values.end(); ++it) {
+      types.push_back(Type::Constant(*it, region));
     }
 
-    objects.push_back(smi);
-    objects.push_back(signed32);
-    objects.push_back(object1);
-    objects.push_back(object2);
-    objects.push_back(array);
+    while (types.size() < kMaxTypes) {
+      size_t i = rng.NextInt(types.size());
+      size_t j = rng.NextInt(types.size());
+      if (i != j) types.push_back(Type::Union(types[i], types[j], region));
+    }
   }
 
   RandomNumberGenerator rng;
 
-  TypeHandle Representation;
-  TypeHandle Semantic;
-  TypeHandle None;
-  TypeHandle Any;
-  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;
+  #define DECLARE_TYPE(name, value) TypeHandle name;
+  BITSET_TYPE_LIST(DECLARE_TYPE)
+  #undef DECLARE_TYPE
 
   TypeHandle ObjectClass;
   TypeHandle ArrayClass;
 
   TypeHandle SmiConstant;
   TypeHandle Signed32Constant;
   TypeHandle ObjectConstant1;
   TypeHandle ObjectConstant2;
-  TypeHandle ArrayConstant1;
-  TypeHandle ArrayConstant2;
+  TypeHandle ArrayConstant;
 
   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;
 
-  typedef std::list<TypeHandle> TypeList;
-  TypeList types;
+  typedef std::vector<TypeHandle> TypeVector;
+  TypeVector types;
 
-  typedef std::list<Handle<i::Object> > ObjectList;
-  ObjectList objects;
+  typedef std::vector<Handle<i::Object> > ValueVector;
+  ValueVector values;
 
   TypeHandle Of(Handle<i::Object> obj) {
     return Type::Of(obj, region_);
   }
 
+  TypeHandle NowOf(Handle<i::Object> obj) {
+    return Type::NowOf(obj, region_);
+  }
+
   TypeHandle Constant(Handle<i::Object> obj) {
     return Type::Constant(obj, region_);
   }
 
   TypeHandle Union(TypeHandle t1, TypeHandle t2) {
     return Type::Union(t1, t2, region_);
   }
   TypeHandle Intersect(TypeHandle t1, TypeHandle t2) {
     return Type::Intersect(t1, t2, region_);
   }
 
   template<class Type2, class TypeHandle2>
   TypeHandle Convert(TypeHandle2 t) {
     return Type::template Convert<Type2>(t, region_);
   }
 
-  TypeHandle Fuzz(int depth = 5) {
-    switch (rng.NextInt(depth == 0 ? 3 : 20)) {
-      case 0: {  // bitset
-        int n = 0
-        #define COUNT_BITSET_TYPES(type, value) + 1
-        BITSET_TYPE_LIST(COUNT_BITSET_TYPES)
-        #undef COUNT_BITSET_TYPES
-        ;
-        int i = rng.NextInt(n);
-        #define PICK_BITSET_TYPE(type, value) \
-          if (i-- == 0) return Type::type(region_);
-        BITSET_TYPE_LIST(PICK_BITSET_TYPE)
-        #undef PICK_BITSET_TYPE
-        UNREACHABLE();
-      }
-      case 1:  // class
-        switch (rng.NextInt(2)) {
-          case 0: return ObjectClass;
-          case 1: return ArrayClass;
-        }
-        UNREACHABLE();
-      case 2:  // constant
-        switch (rng.NextInt(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();
-      default: {  // union
-        int n = rng.NextInt(10);
-        TypeHandle type = None;
-        for (int i = 0; i < n; ++i) {
-          type = Type::Union(type, Fuzz(depth - 1), region_);
-        }
-        return type;
-      }
-    }
-    UNREACHABLE();
-  }
-
  private:
   Region* region_;
 };
 
 
 // Testing auxiliaries (breaking the Type abstraction).
 struct ZoneRep {
   typedef void* Struct;
 
   static bool IsStruct(Type* t, int tag) {
@@ skipping 46 matching lines @@
   }
   static Struct* AsUnion(Handle<HeapType> t) { return AsStruct(t); }
   static int Length(Struct* structured) { return structured->length() - 1; }
 
   static Isolate* ToRegion(Zone* zone, Isolate* isolate) { return isolate; }
 };
 
 
 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::ValueVector::iterator ValueIterator;
+
   Isolate* isolate;
   HandleScope scope;
   Zone zone;
-  Types<Type, TypeHandle, Region> T;
-  typedef typename Types<Type, TypeHandle, Region>::TypeList::iterator
-      TypeIterator;
-  typedef typename Types<Type, TypeHandle, Region>::ObjectList::iterator
-      ObjectIterator;
+  TypesInstance T;
 
   Tests() :
       isolate(CcTest::i_isolate()),
       scope(isolate),
       zone(isolate),
       T(Rep::ToRegion(&zone, isolate), isolate) {
   }
 
   void CheckEqual(TypeHandle type1, TypeHandle type2) {
     CHECK_EQ(Rep::IsBitset(type1), Rep::IsBitset(type2));
@@ skipping 75 matching lines @@
     CHECK(this->IsClass(T.ArrayClass));
 
     CHECK(*T.object_map == this->AsClass(T.ObjectClass));
     CHECK(*T.array_map == this->AsClass(T.ArrayClass));
   }
 
   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));
+    CHECK(this->IsConstant(T.ArrayConstant));
 
     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));
+    CHECK(*T.array == this->AsConstant(T.ArrayConstant));
+  }
+
+  void Of() {
+    CHECK(T.Of(T.smi)->Is(T.SignedSmall));
+    CHECK(T.Of(T.signed32)->Is(T.Signed32));
+    CHECK(T.Of(T.object1)->Is(T.Object));
+    CHECK(T.Of(T.object2)->Is(T.Object));
+    CHECK(T.Of(T.array)->Is(T.Array));
+  }
+
+  void NowOf() {
+    // NowOf(V)->Is(Of(V)) for all V
+    for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) {
+      Handle<i::Object> val = *vt;
+      CHECK(T.NowOf(val)->Is(T.Of(val)));
+    }
+
+    CHECK(T.NowOf(T.smi)->NowIs(T.SignedSmall));
+    CHECK(T.NowOf(T.signed32)->NowIs(T.Signed32));
+    CHECK(T.NowOf(T.object1)->NowIs(T.ObjectClass));
+    CHECK(T.NowOf(T.object2)->NowIs(T.ObjectClass));
+    CHECK(T.NowOf(T.array)->NowIs(T.Array));
   }
 
   void Is() {
     // T->Is(None) implies T = None for all T
     for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) {
       TypeHandle type = *it;
       if (type->Is(T.None)) CheckEqual(type, T.None);
     }
 
     // None->Is(T) for all T
@@ skipping 80 matching lines @@
 
     CheckSub(T.ObjectClass, T.Object);
     CheckSub(T.ArrayClass, T.Object);
     CheckUnordered(T.ObjectClass, T.ArrayClass);
 
     CheckSub(T.SmiConstant, T.SignedSmall);
     CheckSub(T.SmiConstant, T.Signed32);
     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 NowIs() {
     // T->NowIs(None) implies T = None for all T
     for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) {
       TypeHandle type = *it;
       if (type->NowIs(T.None)) CheckEqual(type, T.None);
     }
 
     // None->NowIs(T) for all T
@@ skipping 41 matching lines @@
         TypeHandle type2 = *it2;
         CHECK(!type1->Is(type2) || type1->NowIs(type2));
       }
     }
 
     CHECK(T.ObjectConstant1->NowIs(T.ObjectClass));
     CHECK(T.ObjectConstant2->NowIs(T.ObjectClass));
   }
 
   void Contains() {
-    // T->Contains(O) iff Constant(O)->Is(T) for all T,O
+    // T->Contains(V) iff Constant(V)->Is(T) for all T,V
     for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) {
-      for (ObjectIterator ot = T.objects.begin(); ot != T.objects.end(); ++ot) {
+      for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) {
         TypeHandle type = *it;
-        Handle<i::Object> obj = *ot;
-        CHECK(type->Contains(obj) == T.Constant(obj)->Is(type));
+        Handle<i::Object> val = *vt;
+        CHECK(type->Contains(val) == T.Constant(val)->Is(type));
       }
     }
 
-    // Of(O)->Is(T) implies T->Contains(O) for all T,O
+    // Of(V)->Is(T) implies T->Contains(V) for all T,V
     for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) {
-      for (ObjectIterator ot = T.objects.begin(); ot != T.objects.end(); ++ot) {
+      for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) {
         TypeHandle type = *it;
-        Handle<i::Object> obj = *ot;
-        CHECK(!T.Of(obj)->Is(type) || type->Contains(obj));
+        Handle<i::Object> val = *vt;
+        CHECK(!T.Of(val)->Is(type) || type->Contains(val));
       }
     }
   }
+
+  void NowContains() {
+    // T->NowContains(V) iff Constant(V)->NowIs(T) for all T,V
+    for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) {
+      for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) {
+        TypeHandle type = *it;
+        Handle<i::Object> val = *vt;
+        CHECK(type->NowContains(val) == T.Constant(val)->NowIs(type));
+      }
+    }
+
+    // NowOf(V)->Is(T) implies T->NowContains(V) for all T,V
+    for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) {
+      for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) {
+        TypeHandle type = *it;
+        Handle<i::Object> value = *vt;
+        CHECK(!T.NowOf(value)->NowIs(type) || type->NowContains(value));
+      }
+    }
+
+    // NowOf(V)->NowIs(T) implies T->NowContains(V) for all T,V
+    for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) {
+      for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) {
+        TypeHandle type = *it;
+        Handle<i::Object> val = *vt;
+        CHECK(!T.NowOf(val)->NowIs(type) || type->NowContains(val));
+      }
+    }
+
+    // T->Contains(V) implies T->NowContains(V) for all T,V
+    for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) {
+      for (ValueIterator vt = T.values.begin(); vt != T.values.end(); ++vt) {
+        TypeHandle type = *it;
+        Handle<i::Object> val = *vt;
+        CHECK(!type->Contains(val) || type->NowContains(val));
+      }
+    }
+  }
 
   void Maybe() {
     // T->Maybe(T) for all inhabited T
     for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) {
       TypeHandle type = *it;
       CHECK(type->Maybe(type) || !type->IsInhabited());
     }
 
-    // Commutativity
+    // Symmetry
     for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) {
       for (TypeIterator it2 = T.types.begin(); it2 != T.types.end(); ++it2) {
         TypeHandle type1 = *it1;
         TypeHandle type2 = *it2;
         CHECK(type1->Maybe(type2) == type2->Maybe(type1));
       }
     }
 
     // T1->Is(T2) implies T1->Maybe(T2) or T1 is uninhabited for all T1,T2
     for (TypeIterator it1 = T.types.begin(); it1 != T.types.end(); ++it1) {
@@ skipping 48 matching lines @@
     CheckOverlap(T.ObjectClass, T.ObjectClass, T.Semantic);
     CheckOverlap(T.ArrayClass, T.ArrayClass, T.Semantic);
     CheckDisjoint(T.ObjectClass, T.ArrayClass, T.Semantic);
 
     CheckOverlap(T.SmiConstant, T.SignedSmall, T.Semantic);
     CheckOverlap(T.SmiConstant, T.Signed32, T.Semantic);
     CheckOverlap(T.SmiConstant, T.Number, T.Semantic);
     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)));
 
     CheckEqual(T.Union(T.None, T.Number), T.Number);
     CheckEqual(T.Union(T.Object, T.Proxy), T.Receiver);
     CheckEqual(T.Union(T.Number, T.String), T.Union(T.String, T.Number));
     CheckSub(T.Union(T.Number, T.String), T.Any);
 
     // Class-class
     CHECK(this->IsClass(T.Union(T.ObjectClass, T.ObjectClass)));
     CHECK(this->IsUnion(T.Union(T.ObjectClass, T.ArrayClass)));
 
     CheckEqual(T.Union(T.ObjectClass, T.ObjectClass), T.ObjectClass);
     CheckSub(T.None, T.Union(T.ObjectClass, T.ArrayClass));
     CheckSub(T.Union(T.ObjectClass, T.ArrayClass), T.Any);
     CheckSub(T.ObjectClass, T.Union(T.ObjectClass, T.ArrayClass));
     CheckSub(T.ArrayClass, T.Union(T.ObjectClass, T.ArrayClass));
     CheckSub(T.Union(T.ObjectClass, T.ArrayClass), T.Object);
     CheckUnordered(T.Union(T.ObjectClass, T.ArrayClass), T.Array);
     CheckOverlap(T.Union(T.ObjectClass, T.ArrayClass), T.Array, T.Semantic);
     CheckDisjoint(T.Union(T.ObjectClass, T.ArrayClass), T.Number, T.Semantic);
 
     // Constant-constant
     CHECK(this->IsConstant(T.Union(T.ObjectConstant1, T.ObjectConstant1)));
-    CHECK(this->IsConstant(T.Union(T.ArrayConstant1, T.ArrayConstant1)));
+    CHECK(this->IsConstant(T.Union(T.ArrayConstant, T.ArrayConstant)));
     CHECK(this->IsUnion(T.Union(T.ObjectConstant1, T.ObjectConstant2)));
 
     CheckEqual(
         T.Union(T.ObjectConstant1, T.ObjectConstant1),
         T.ObjectConstant1);
-    CheckEqual(T.Union(T.ArrayConstant1, T.ArrayConstant1), T.ArrayConstant1);
-    CheckEqual(T.Union(T.ArrayConstant1, T.ArrayConstant1), T.ArrayConstant2);
+    CheckEqual(T.Union(T.ArrayConstant, T.ArrayConstant), T.ArrayConstant);
     CheckSub(T.None, T.Union(T.ObjectConstant1, T.ObjectConstant2));
     CheckSub(T.Union(T.ObjectConstant1, T.ObjectConstant2), T.Any);
     CheckSub(T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2));
     CheckSub(T.ObjectConstant2, T.Union(T.ObjectConstant1, T.ObjectConstant2));
-    CheckSub(T.ArrayConstant2, T.Union(T.ArrayConstant1, T.ObjectConstant2));
     CheckSub(T.Union(T.ObjectConstant1, T.ObjectConstant2), T.Object);
     CheckUnordered(
         T.Union(T.ObjectConstant1, T.ObjectConstant2), T.ObjectClass);
-    CheckUnordered(T.Union(T.ObjectConstant1, T.ArrayConstant1), T.Array);
+    CheckUnordered(T.Union(T.ObjectConstant1, T.ArrayConstant), T.Array);
     CheckOverlap(
-        T.Union(T.ObjectConstant1, T.ArrayConstant1), T.Array, T.Semantic);
-    CheckOverlap(
-        T.Union(T.ObjectConstant1, T.ArrayConstant1), T.ArrayConstant2,
-        T.Semantic);
+        T.Union(T.ObjectConstant1, T.ArrayConstant), T.Array, T.Semantic);
     CheckDisjoint(
-        T.Union(T.ObjectConstant1, T.ArrayConstant1), T.Number, T.Semantic);
+        T.Union(T.ObjectConstant1, T.ArrayConstant), T.Number, T.Semantic);
     CheckDisjoint(
-        T.Union(T.ObjectConstant1, T.ArrayConstant1), T.ObjectClass,
+        T.Union(T.ObjectConstant1, T.ArrayConstant), T.ObjectClass,
         T.Semantic);
 
     // Bitset-class
     CHECK(this->IsBitset(T.Union(T.ObjectClass, T.Object)));
     CHECK(this->IsUnion(T.Union(T.ObjectClass, T.Number)));
 
     CheckEqual(T.Union(T.ObjectClass, T.Object), T.Object);
     CheckSub(T.None, T.Union(T.ObjectClass, T.Number));
     CheckSub(T.Union(T.ObjectClass, T.Number), T.Any);
     CheckSub(
@@ skipping 25 matching lines @@
     CHECK(this->IsUnion(T.Union(T.ArrayClass, T.ObjectConstant2)));
 
     CheckSub(T.None, T.Union(T.ObjectConstant1, T.ArrayClass));
     CheckSub(T.Union(T.ObjectConstant1, T.ArrayClass), T.Any);
     CheckSub(T.Union(T.ObjectConstant1, T.ArrayClass), T.Object);
     CheckSub(T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ArrayClass));
     CheckSub(T.ArrayClass, T.Union(T.ObjectConstant1, T.ArrayClass));
     CheckUnordered(T.ObjectClass, T.Union(T.ObjectConstant1, T.ArrayClass));
     CheckSub(
         T.Union(T.ObjectConstant1, T.ArrayClass), T.Union(T.Array, T.Object));
-    CheckUnordered(T.Union(T.ObjectConstant1, T.ArrayClass), T.ArrayConstant1);
+    CheckUnordered(T.Union(T.ObjectConstant1, T.ArrayClass), T.ArrayConstant);
     CheckDisjoint(
         T.Union(T.ObjectConstant1, T.ArrayClass), T.ObjectConstant2,
         T.Semantic);
     CheckDisjoint(
         T.Union(T.ObjectConstant1, T.ArrayClass), T.ObjectClass, T.Semantic);
 
     // Bitset-union
     CHECK(this->IsBitset(
         T.Union(T.Object, T.Union(T.ObjectConstant1, T.ObjectClass))));
     CHECK(this->IsUnion(
@@ skipping 40 matching lines @@
         T.Union(T.ObjectClass, T.Union(T.ObjectConstant1, T.ObjectClass)),
         T.Object);
     CheckEqual(
         T.Union(T.Union(T.ArrayClass, T.ObjectConstant2), T.ArrayClass),
         T.Union(T.ArrayClass, T.ObjectConstant2));
 
     // Constant-union
     CHECK(this->IsUnion(T.Union(
         T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2))));
     CHECK(this->IsUnion(T.Union(
-        T.Union(T.ArrayConstant1, T.ObjectClass), T.ObjectConstant1)));
+        T.Union(T.ArrayConstant, T.ObjectClass), T.ObjectConstant1)));
     CHECK(this->IsUnion(T.Union(
-        T.Union(T.ArrayConstant1, T.ObjectConstant2), T.ObjectConstant1)));
+        T.Union(T.ArrayConstant, T.ObjectConstant2), T.ObjectConstant1)));
 
     CheckEqual(
         T.Union(
             T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2)),
         T.Union(T.ObjectConstant2, T.ObjectConstant1));
     CheckEqual(
         T.Union(
-            T.Union(T.ArrayConstant1, T.ObjectConstant2), T.ObjectConstant1),
+            T.Union(T.ArrayConstant, T.ObjectConstant2), T.ObjectConstant1),
         T.Union(
-            T.ObjectConstant2, T.Union(T.ArrayConstant1, T.ObjectConstant1)));
+            T.ObjectConstant2, T.Union(T.ArrayConstant, T.ObjectConstant1)));
 
     // Union-union
     CHECK(this->IsBitset(T.Union(
         T.Union(T.Number, T.ArrayClass),
         T.Union(T.Signed32, T.Array))));
     CHECK(this->IsUnion(T.Union(
         T.Union(T.Number, T.ArrayClass),
         T.Union(T.ObjectClass, T.ArrayClass))));
 
     CheckEqual(
         T.Union(
             T.Union(T.ObjectConstant2, T.ObjectConstant1),
             T.Union(T.ObjectConstant1, T.ObjectConstant2)),
         T.Union(T.ObjectConstant2, T.ObjectConstant1));
     CheckEqual(
         T.Union(
-            T.Union(T.ObjectConstant2, T.ArrayConstant1),
-            T.Union(T.ObjectConstant1, T.ArrayConstant2)),
-        T.Union(
-            T.Union(T.ObjectConstant1, T.ObjectConstant2),
-            T.ArrayConstant1));
-    CheckEqual(
-        T.Union(
             T.Union(T.Number, T.ArrayClass),
             T.Union(T.SignedSmall, T.Array)),
         T.Union(T.Number, T.Array));
   }
 
   void Intersect() {
     // Bitset-bitset
     CHECK(this->IsBitset(T.Intersect(T.Object, T.Number)));
     CHECK(this->IsBitset(T.Intersect(T.Object, T.Object)));
     CHECK(this->IsBitset(T.Intersect(T.Any, T.None)));
 
     CheckEqual(T.Intersect(T.None, T.Number), T.None);
     CheckSub(T.Intersect(T.Object, T.Proxy), T.Representation);
     CheckEqual(T.Intersect(T.Name, T.String), T.Intersect(T.String, T.Name));
     CheckEqual(T.Intersect(T.UniqueName, T.String), T.InternalizedString);
 
     // Class-class
     CHECK(this->IsClass(T.Intersect(T.ObjectClass, T.ObjectClass)));
     CHECK(this->IsBitset(T.Intersect(T.ObjectClass, T.ArrayClass)));
 
     CheckEqual(T.Intersect(T.ObjectClass, T.ObjectClass), T.ObjectClass);
     CheckEqual(T.Intersect(T.ObjectClass, T.ArrayClass), T.None);
 
     // Constant-constant
     CHECK(this->IsConstant(T.Intersect(T.ObjectConstant1, T.ObjectConstant1)));
-    CHECK(this->IsConstant(T.Intersect(T.ArrayConstant1, T.ArrayConstant2)));
     CHECK(this->IsBitset(T.Intersect(T.ObjectConstant1, T.ObjectConstant2)));
 
     CheckEqual(
         T.Intersect(T.ObjectConstant1, T.ObjectConstant1), T.ObjectConstant1);
-    CheckEqual(
-        T.Intersect(T.ArrayConstant1, T.ArrayConstant2), T.ArrayConstant1);
     CheckEqual(T.Intersect(T.ObjectConstant1, T.ObjectConstant2), T.None);
 
     // Bitset-class
     CHECK(this->IsClass(T.Intersect(T.ObjectClass, T.Object)));
     CHECK(this->IsBitset(T.Intersect(T.ObjectClass, T.Number)));
 
     CheckEqual(T.Intersect(T.ObjectClass, T.Object), T.ObjectClass);
     CheckSub(T.Intersect(T.ObjectClass, T.Array), T.Representation);
     CheckSub(T.Intersect(T.ObjectClass, T.Number), T.Representation);
 
@@ skipping 25 matching lines @@
     CheckEqual(
         T.Intersect(T.Union(T.ArrayClass, T.ObjectConstant1), T.Number),
         T.None);
 
     // Class-union
     CHECK(this->IsClass(
         T.Intersect(T.Union(T.ArrayClass, T.ObjectConstant2), T.ArrayClass)));
     CHECK(this->IsClass(
         T.Intersect(T.Union(T.Object, T.SmiConstant), T.ArrayClass)));
     CHECK(this->IsBitset(
-        T.Intersect(T.Union(T.ObjectClass, T.ArrayConstant1), T.ArrayClass)));
+        T.Intersect(T.Union(T.ObjectClass, T.ArrayConstant), T.ArrayClass)));
 
     CheckEqual(
         T.Intersect(T.ArrayClass, T.Union(T.ObjectConstant2, T.ArrayClass)),
         T.ArrayClass);
     CheckEqual(
         T.Intersect(T.ArrayClass, T.Union(T.Object, T.SmiConstant)),
         T.ArrayClass);
     CheckEqual(
-        T.Intersect(T.Union(T.ObjectClass, T.ArrayConstant1), T.ArrayClass),
+        T.Intersect(T.Union(T.ObjectClass, T.ArrayConstant), T.ArrayClass),
         T.None);
 
     // Constant-union
     CHECK(this->IsConstant(T.Intersect(
         T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2))));
     CHECK(this->IsConstant(T.Intersect(
         T.Union(T.Number, T.ObjectClass), T.SmiConstant)));
     CHECK(this->IsBitset(T.Intersect(
-        T.Union(T.ArrayConstant1, T.ObjectClass), T.ObjectConstant1)));
+        T.Union(T.ArrayConstant, T.ObjectClass), T.ObjectConstant1)));
 
     CheckEqual(
         T.Intersect(
             T.ObjectConstant1, T.Union(T.ObjectConstant1, T.ObjectConstant2)),
         T.ObjectConstant1);
     CheckEqual(
         T.Intersect(T.SmiConstant, T.Union(T.Number, T.ObjectConstant2)),
         T.SmiConstant);
     CheckEqual(
         T.Intersect(
-            T.Union(T.ArrayConstant1, T.ObjectClass), T.ObjectConstant1),
+            T.Union(T.ArrayConstant, T.ObjectClass), T.ObjectConstant1),
         T.None);
 
     // Union-union
     CHECK(this->IsUnion(T.Intersect(
         T.Union(T.Number, T.ArrayClass), T.Union(T.Signed32, T.Array))));
     CHECK(this->IsBitset(T.Intersect(
         T.Union(T.Number, T.ObjectClass), T.Union(T.Signed32, T.Array))));
 
     CheckEqual(
         T.Intersect(
             T.Union(T.Number, T.ArrayClass),
             T.Union(T.SignedSmall, T.Array)),
         T.Union(T.SignedSmall, T.ArrayClass));
     CheckEqual(
         T.Intersect(
             T.Union(T.Number, T.ObjectClass),
             T.Union(T.Signed32, T.Array)),
         T.Signed32);
     CheckEqual(
         T.Intersect(
             T.Union(T.ObjectConstant2, T.ObjectConstant1),
             T.Union(T.ObjectConstant1, T.ObjectConstant2)),
         T.Union(T.ObjectConstant2, T.ObjectConstant1));
     CheckEqual(
         T.Intersect(
             T.Union(
                 T.Union(T.ObjectConstant2, T.ObjectConstant1), T.ArrayClass),
             T.Union(
                 T.ObjectConstant1,
-                T.Union(T.ArrayConstant1, T.ObjectConstant2))),
+                T.Union(T.ArrayConstant, T.ObjectConstant2))),
         T.Union(T.ObjectConstant2, T.ObjectConstant1));
-    CheckEqual(
-        T.Intersect(
-            T.Union(T.ObjectConstant2, T.ArrayConstant1),
-            T.Union(T.ObjectConstant1, T.ArrayConstant2)),
-        T.ArrayConstant1);
   }
 
   template<class Type2, class TypeHandle2, class Region2, class Rep2>
   void Convert() {
     Types<Type2, TypeHandle2, Region2> T2(
         Rep2::ToRegion(&zone, isolate), isolate);
-    for (int i = 0; i < 100; ++i) {
-      TypeHandle type = T.Fuzz();
+    for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) {
+      TypeHandle type = *it;
       CheckEqual(type,
                  T.template Convert<Type2>(T2.template Convert<Type>(type)));
     }
   }
 };
 
 typedef Tests<Type, Type*, Zone, ZoneRep> ZoneTests;
 typedef Tests<HeapType, Handle<HeapType>, Isolate, HeapRep> HeapTests;
 
 
@@ skipping 11 matching lines @@
 }
 
 
 TEST(Constant) {
   CcTest::InitializeVM();
   ZoneTests().Constant();
   HeapTests().Constant();
 }
 
 
+TEST(Of) {
+  CcTest::InitializeVM();
+  ZoneTests().Of();
+  HeapTests().Of();
+}
+
+
+TEST(NowOf) {
+  CcTest::InitializeVM();
+  ZoneTests().NowOf();
+  HeapTests().NowOf();
+}
+
+
 TEST(Is) {
   CcTest::InitializeVM();
   ZoneTests().Is();
   HeapTests().Is();
 }
 
 
 TEST(NowIs) {
   CcTest::InitializeVM();
   ZoneTests().NowIs();
   HeapTests().NowIs();
 }
 
 
 TEST(Contains) {
   CcTest::InitializeVM();
   ZoneTests().Contains();
   HeapTests().Contains();
 }
 
 
+TEST(NowContains) {
+  CcTest::InitializeVM();
+  ZoneTests().NowContains();
+  HeapTests().NowContains();
+}
+
+
 TEST(Maybe) {
   CcTest::InitializeVM();
   ZoneTests().Maybe();
   HeapTests().Maybe();
 }
 
 
 TEST(Union) {
   CcTest::InitializeVM();
   ZoneTests().Union();
   HeapTests().Union();
 }
 
 
 TEST(Intersect) {
   CcTest::InitializeVM();
   ZoneTests().Intersect();
   HeapTests().Intersect();
 }
 
 
 TEST(Convert) {
   CcTest::InitializeVM();
   ZoneTests().Convert<HeapType, Handle<HeapType>, Isolate, HeapRep>();
   HeapTests().Convert<Type, Type*, Zone, ZoneRep>();
 }