Inline TypeImpl::NowContains().

src/types.h

 // 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.
 
 #ifndef V8_TYPES_H_
 #define V8_TYPES_H_
 
 #include "handles.h"
 
 namespace v8 {
@@ skipping 253 matching lines @@
 
   // State-dependent versions of Of and Is that consider subtyping between
   // a constant and its map class.
   static TypeHandle NowOf(i::Object* value, Region* region);
   static TypeHandle NowOf(i::Handle<i::Object> value, Region* region) {
     return NowOf(*value, region);
   }
   bool NowIs(TypeImpl* that);
   template<class TypeHandle>
   bool NowIs(TypeHandle that)  { return this->NowIs(*that); }
-  bool NowContains(i::Object* val);
+  bool NowContains(i::Object* val) {

[rossberg, 2014/04/11 09:19:37]

Can we move that to types-inl?

[Benedikt Meurer, 2014/04/11 09:23:30]

Done.

+    DisallowHeapAllocation no_allocation;
+    if (this->IsAny()) return true;
+    if (val->IsHeapObject()) {
+      i::Map* map = i::HeapObject::cast(val)->map();
+      for (Iterator<i::Map> it = this->Classes(); !it.Done(); it.Advance()) {
+        if (*it.Current() == map) return true;
+      }
+    }
+    return this->Contains(val);
+  }
   bool NowContains(i::Handle<i::Object> val) { return this->NowContains(*val); }
 
   bool IsClass() { return Config::is_class(this); }
   bool IsConstant() { return Config::is_constant(this); }
   i::Handle<i::Map> AsClass() { return Config::as_class(this); }
   i::Handle<i::Object> AsConstant() { return Config::as_constant(this); }
 
   int NumClasses();
   int NumConstants();
 
@@ skipping 242 matching lines @@
   bool Narrows(BoundsImpl that) {
     return that.lower->Is(this->lower) && this->upper->Is(that.upper);
   }
 };
 
 typedef BoundsImpl<ZoneTypeConfig> Bounds;
 
 } }  // namespace v8::internal
 
 #endif  // V8_TYPES_H_