Fix various bugs in the type systems, and improve test coverage.

src/types.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "types.h"
 
 #include "string-stream.h"
 #include "types-inl.h"
 
 namespace v8 {
@@ skipping 288 matching lines @@
     }
     return false;
   }
 
   return false;
 }
 
 
 template<class Config>
 bool TypeImpl<Config>::NowIs(TypeImpl* that) {
-  return this->Is(that) ||
-      (this->IsConstant() && that->IsClass() &&
-       this->AsConstant()->IsHeapObject() &&
-       i::HeapObject::cast(*this->AsConstant())->map() == *that->AsClass());
+  if (this->Is(that)) return true;
+  if (this->IsConstant() && this->AsConstant()->IsHeapObject()) {
+    i::Handle<i::Map> map(i::HeapObject::cast(*this->AsConstant())->map());
+    for (Iterator<i::Map> it = that->Classes(); !it.Done(); it.Advance()) {
+      if (*it.Current() == *map) return true;
+    }
+  }
+  return false;
 }
 
 
 // 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());
   }
@@ skipping 28 matching lines @@
   if (this->IsConstant()) {
     return that->IsConstant() && *this->AsConstant() == *that->AsConstant();
   }
 
   return false;
 }
 
 
 template<class Config>
 bool TypeImpl<Config>::Contains(i::Object* value) {
-  if (this->IsConstant()) {
-    return *this->AsConstant() == value;
+  for (Iterator<i::Object> it = this->Constants(); !it.Done(); it.Advance()) {
+    if (*it.Current() == value) return true;
   }
   return Config::from_bitset(LubBitset(value))->Is(this);
 }
 
 
 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());
@@ skipping 304 matching lines @@
 template class TypeImpl<HeapTypeConfig>::Iterator<i::Object>;
 
 template TypeImpl<ZoneTypeConfig>::TypeHandle
   TypeImpl<ZoneTypeConfig>::Convert<HeapType>(
     TypeImpl<HeapTypeConfig>::TypeHandle, TypeImpl<ZoneTypeConfig>::Region*);
 template TypeImpl<HeapTypeConfig>::TypeHandle
   TypeImpl<HeapTypeConfig>::Convert<Type>(
     TypeImpl<ZoneTypeConfig>::TypeHandle, TypeImpl<HeapTypeConfig>::Region*);
 
 } }  // namespace v8::internal