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

Add tests for TypeImpl::Of(), TypeImpl::NowOf() and
TypeImpl::NowContains(). Improves the implementation of
TypeImpl::NowIs() to match that of TypeImpl::NowContains().

Mark test-types with NO_VARIANTS to speedup testing, since
the variants do not affect the type system at all.

Also improve test coverage for types.

TEST=cctest/test-types
R=rossberg@chromium.org

Review URL: https://codereview.chromium.org/230673002

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@20639 ce2b1a6d-e550-0410-aec6-3dcde31c8c00

src/types.cc

@@ -306,28 +306,23 @@ bool TypeImpl<Config>::SlowIs(TypeImpl* that) {
 
 template<class Config>
 bool TypeImpl<Config>::NowIs(TypeImpl* that) {
-  if (this->Is(that)) return true;
-  if (this->IsConstant() && this->AsConstant()->IsHeapObject()) {
-    i::Handle<i::Map> map(i::HeapObject::cast(*this->AsConstant())->map());
+  if (this->IsConstant()) {
+    DisallowHeapAllocation no_allocation;
+    i::Object* object = *this->AsConstant();
+    if (object->IsHeapObject()) {
+      i::Map* map = i::HeapObject::cast(object)->map();
       for (Iterator<i::Map> it = that->Classes(); !it.Done(); it.Advance()) {
-      if (*it.Current() == *map) return true;
+        if (*it.Current() == map) return true;
       }
     }
-  return false;
+  }
+  return this->Is(that);
 }
 
 
 // Check this overlaps that.
 template<class Config>
 bool TypeImpl<Config>::Maybe(TypeImpl* that) {
-  // Fast path for bitsets.
-  if (this->IsBitset()) {
-    return IsInhabited(this->AsBitset() & that->LubBitset());
-  }
-  if (that->IsBitset()) {
-    return IsInhabited(this->LubBitset() & that->AsBitset());
-  }
-
   // (T1 \/ ... \/ Tn) overlaps T <=> (T1 overlaps T) \/ ... \/ (Tn overlaps T)
   if (this->IsUnion()) {
     StructHandle unioned = this->AsUnion();
@@ -349,6 +344,13 @@ bool TypeImpl<Config>::Maybe(TypeImpl* that) {
   }
 
   ASSERT(!this->IsUnion() && !that->IsUnion());
+  if (this->IsBitset()) {
+    return IsInhabited(this->AsBitset() & that->LubBitset());
+  }
+  if (that->IsBitset()) {
+    return IsInhabited(this->LubBitset() & that->AsBitset());
+  }
+
   if (this->IsClass()) {
     return that->IsClass() && *this->AsClass() == *that->AsClass();
   }
@@ -371,9 +373,14 @@ bool TypeImpl<Config>::Contains(i::Object* value) {
 
 template<class Config>
 bool TypeImpl<Config>::NowContains(i::Object* value) {
-  return this->Contains(value) ||
-      (this->IsClass() && value->IsHeapObject() &&
-       *this->AsClass() == i::HeapObject::cast(value)->map());
+  if (value->IsHeapObject()) {
+    DisallowHeapAllocation no_allocation;
+    i::Map* map = i::HeapObject::cast(value)->map();
+    for (Iterator<i::Map> it = this->Classes(); !it.Done(); it.Advance()) {
+      if (*it.Current() == map) return true;
+    }
+  }
+  return this->Contains(value);
 }
 
 

test/cctest/cctest.status

@@ -65,6 +65,10 @@
   # are actually 13 * 38 * 5 * 128 = 316160 individual tests hidden here.
   'test-parsing/ParserSync': [PASS, NO_VARIANTS],
 
+  # This tests only the type system, so there is no point in running several
+  # variants.
+  'test-types/*': [PASS, NO_VARIANTS],
+
   # BUG(2999).
   'test-cpu-profiler/CollectCpuProfile': [PASS, FLAKY],