Provide Type::Contains methods.

src/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 253 matching lines @@
     // All but the first are non-bitsets and thus would yield kNone anyway.
     return Config::union_get(this->AsUnion(), 0)->GlbBitset();
   } else {
     return kNone;
   }
 }
 
 
 // Most precise _current_ type of a value (usually its class).
 template<class Config>
-typename TypeImpl<Config>::TypeHandle TypeImpl<Config>::OfCurrently(
+typename TypeImpl<Config>::TypeHandle TypeImpl<Config>::NowOf(
     i::Handle<i::Object> value, Region* region) {
   if (value->IsSmi() ||
       i::HeapObject::cast(*value)->map()->instance_type() == HEAP_NUMBER_TYPE ||
       i::HeapObject::cast(*value)->map()->instance_type() == ODDBALL_TYPE) {
     return Of(value, region);
   }
   return Class(i::handle(i::HeapObject::cast(*value)->map()), region);
 }
 
 
@@ skipping 34 matching lines @@
       if (this->IsBitset()) break;  // Fast fail, only first field is a bitset.
     }
     return false;
   }
 
   return false;
 }
 
 
 template<class Config>
-bool TypeImpl<Config>::IsCurrently(TypeImpl* that) {
+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());
 }
 
 
 // Check this overlaps that.
 template<class Config>
 bool TypeImpl<Config>::Maybe(TypeImpl* that) {
@@ skipping 31 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;
+  }
+  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());
+}
+
+
+template<class Config>
 bool TypeImpl<Config>::InUnion(UnionedHandle unioned, int current_size) {
   ASSERT(!this->IsUnion());
   for (int i = 0; i < current_size; ++i) {
     TypeHandle type = Config::union_get(unioned, i);
     if (this->Is(type)) return true;
   }
   return false;
 }
 
 
@@ skipping 296 matching lines @@
 
 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