Introduce Type::IsCurrently

src/types.h

 // 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 135 matching lines @@
     return from_handle(isolate->factory()->NewBox(value));
   }
 
   static Type* Union(Handle<Type> type1, Handle<Type> type2);
   static Type* Intersect(Handle<Type> type1, Handle<Type> type2);
   static Type* Optional(Handle<Type> type);  // type \/ Undefined
 
   static Type* Of(Handle<i::Object> value) {
     return from_bitset(LubBitset(*value));
   }
-  static Type* CurrentOf(Handle<i::Object> value);
 
   bool Is(Type* that) { return (this == that) ? true : SlowIs(that); }
   bool Is(Handle<Type> that) { return this->Is(*that); }
   bool Maybe(Type* that);
   bool Maybe(Handle<Type> that) { return this->Maybe(*that); }
 
+  // State-dependent versions of Of and Is that consider subtyping between
+  // a constant and its map class.
+  static Type* OfCurrently(Handle<i::Object> value);
+  bool IsCurrently(Type* that);
+  bool IsCurrently(Handle<Type> that)  { return this->IsCurrently(*that); }
+
   bool IsClass() { return is_class(); }
   bool IsConstant() { return is_constant(); }
   Handle<i::Map> AsClass() { return as_class(); }
   Handle<i::Object> AsConstant() { return as_constant(); }
 
   int NumClasses();
   int NumConstants();
 
   template<class T>
   class Iterator {
@@ skipping 150 matching lines @@
   static Bounds NarrowUpper(Bounds b, Handle<Type> t, Isolate* isl) {
     return Bounds(
         handle(Type::Intersect(b.lower, t), isl),
         handle(Type::Intersect(b.upper, t), isl));
   }
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_TYPES_H_