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"
 
 using namespace v8::internal;
 
 template<class Type, class TypeHandle, class Region>
 class Types {
  public:
   Types(Region* region, Isolate* isolate) :
@@ skipping 28 matching lines @@
     array = isolate->factory()->NewJSArray(20);
     ObjectClass = Type::Class(object_map, region);
     ArrayClass = Type::Class(array_map, region);
     SmiConstant = Type::Constant(smi, region);
     Signed32Constant = Type::Constant(signed32, region);
     ObjectConstant1 = Type::Constant(object1, region);
     ObjectConstant2 = Type::Constant(object2, region);
     ArrayConstant1 = Type::Constant(array, region);
     ArrayConstant2 = Type::Constant(array, region);
 
-    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());
-    }
-
     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();

[rossberg, 2014/04/09 13:59:10]

I thought we shouldn't use rand... :)

[Benedikt Meurer, 2014/04/10 05:19:16]

Another CL...

+      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;
@@ skipping 23 matching lines @@
 
   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> > ObjectVector;
+  ObjectVector objects;
 
   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) {
     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 (rand() % (depth == 0 ? 3 : 20)) {
-      case 0: {  // bitset
-        int n = 0
-        #define COUNT_BITSET_TYPES(type, value) + 1
-        BITSET_TYPE_LIST(COUNT_BITSET_TYPES)
-        #undef COUNT_BITSET_TYPES
-        ;
-        int i = rand() % n;
-        #define PICK_BITSET_TYPE(type, value) \
-          if (i-- == 0) return Type::type(region_);
-        BITSET_TYPE_LIST(PICK_BITSET_TYPE)
-        #undef PICK_BITSET_TYPE
-        UNREACHABLE();
-      }
-      case 1:  // class
-        switch (rand() % 2) {
-          case 0: return ObjectClass;
-          case 1: return ArrayClass;
-        }
-        UNREACHABLE();
-      case 2:  // constant
-        switch (rand() % 6) {
-          case 0: return SmiConstant;
-          case 1: return Signed32Constant;
-          case 2: return ObjectConstant1;
-          case 3: return ObjectConstant2;
-          case 4: return ArrayConstant1;
-          case 5: return ArrayConstant2;
-        }
-        UNREACHABLE();
-      default: {  // union
-        int n = rand() % 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 50 matching lines @@
   static Isolate* ToRegion(Zone* zone, Isolate* isolate) { return isolate; }
 };
 
 
 template<class Type, class TypeHandle, class Region, class Rep>
 struct Tests : Rep {
   Isolate* isolate;
   HandleScope scope;
   Zone zone;
   Types<Type, TypeHandle, Region> T;
-  typedef typename Types<Type, TypeHandle, Region>::TypeList::iterator
+  typedef typename Types<Type, TypeHandle, Region>::TypeVector::iterator
       TypeIterator;
-  typedef typename Types<Type, TypeHandle, Region>::ObjectList::iterator
+  typedef typename Types<Type, TypeHandle, Region>::ObjectVector::iterator
       ObjectIterator;
 
   Tests() :
       isolate(CcTest::i_isolate()),
       scope(isolate),
       zone(isolate),
       T(Rep::ToRegion(&zone, isolate), isolate) {
   }
 
   void CheckEqual(TypeHandle type1, TypeHandle type2) {
@@ skipping 709 matching lines @@
         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 58 matching lines @@
   ZoneTests().Intersect();
   HeapTests().Intersect();
 }
 
 
 TEST(Convert) {
   CcTest::InitializeVM();
   ZoneTests().Convert<HeapType, Handle<HeapType>, Isolate, HeapRep>();
   HeapTests().Convert<Type, Type*, Zone, ZoneRep>();
 }