Fix symmetry of Maybe 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
@@ skipping 17 matching lines @@
 #include <vector>
 
 #include "cctest.h"
 #include "types.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);
+    for (ObjectVector::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);
-
-    static const size_t kMaxTypes = 300;
-    types.reserve(kMaxTypes);
-#define PUSH_BACK_BITSET_TYPE(type, value)  \
-    types.push_back(Type::type(region));
-    BITSET_TYPE_LIST(PUSH_BACK_BITSET_TYPE)
-#undef PUSH_BACK_BITSET_TYPE
-    types.push_back(ObjectClass);
-    types.push_back(ArrayClass);
-    for (ObjectVector::iterator it = objects.begin(); it != objects.end(); ++it)
-      types.push_back(Type::Constant(*it, region));
     while (types.size() < kMaxTypes) {
       size_t i = rand() % types.size();
       size_t j = rand() % types.size();
       if (i != j) types.push_back(Type::Union(types[i], types[j], region));
     }
   }
 
-  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;
 
   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::vector<TypeHandle> TypeVector;
   TypeVector types;
 
   typedef std::vector<Handle<i::Object> > ObjectVector;
-  ObjectVector objects;
+  ObjectVector values;
 
   TypeHandle Of(Handle<i::Object> obj) {
     return Type::Of(obj, region_);
   }
 
   TypeHandle Constant(Handle<i::Object> obj) {
     return Type::Constant(obj, region_);
   }
 
   TypeHandle Union(TypeHandle t1, TypeHandle t2) {
@@ skipping 67 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::ObjectVector::iterator ObjectIterator;
+
   Isolate* isolate;
   HandleScope scope;
   Zone zone;
-  Types<Type, TypeHandle, Region> T;
-  typedef typename Types<Type, TypeHandle, Region>::TypeVector::iterator
-      TypeIterator;
-  typedef typename Types<Type, TypeHandle, Region>::ObjectVector::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 257 matching lines @@
       }
     }
 
     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
     for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) {
-      for (ObjectIterator ot = T.objects.begin(); ot != T.objects.end(); ++ot) {
+      for (ObjectIterator ot = T.values.begin(); ot != T.values.end(); ++ot) {
         TypeHandle type = *it;
         Handle<i::Object> obj = *ot;
         CHECK(type->Contains(obj) == T.Constant(obj)->Is(type));
       }
     }
 
     // Of(O)->Is(T) implies T->Contains(O) for all T,O
     for (TypeIterator it = T.types.begin(); it != T.types.end(); ++it) {
-      for (ObjectIterator ot = T.objects.begin(); ot != T.objects.end(); ++ot) {
+      for (ObjectIterator ot = T.values.begin(); ot != T.values.end(); ++ot) {
         TypeHandle type = *it;
         Handle<i::Object> obj = *ot;
         CHECK(!T.Of(obj)->Is(type) || type->Contains(obj));
       }
     }
   }
 
   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 486 matching lines @@
   ZoneTests().Intersect();
   HeapTests().Intersect();
 }
 
 
 TEST(Convert) {
   CcTest::InitializeVM();
   ZoneTests().Convert<HeapType, Handle<HeapType>, Isolate, HeapRep>();
   HeapTests().Convert<Type, Type*, Zone, ZoneRep>();
 }