v8-object.h

Go to the documentation of this file.

// Copyright 2021 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 INCLUDE_V8_OBJECT_H_
#define INCLUDE_V8_OBJECT_H_
 
#include <type_traits>
 
#include "cppgc/garbage-collected.h"
#include "cppgc/name-provider.h"
#include "cppgc/type-traits.h"
#include "v8-internal.h"           // NOLINT(build/include_directory)
#include "v8-local-handle.h"       // NOLINT(build/include_directory)
#include "v8-maybe.h"              // NOLINT(build/include_directory)
#include "v8-persistent-handle.h"  // NOLINT(build/include_directory)
#include "v8-primitive.h"          // NOLINT(build/include_directory)
#include "v8-sandbox.h"            // NOLINT(build/include_directory)
#include "v8-traced-handle.h"      // NOLINT(build/include_directory)
#include "v8-value.h"              // NOLINT(build/include_directory)
#include "v8config.h"              // NOLINT(build/include_directory)
 
namespace v8 {
 
class Array;
class Function;
class FunctionTemplate;
template <typename T>
class PropertyCallbackInfo;
 
using EmbedderDataTypeTag = uint16_t;
 
constexpr EmbedderDataTypeTag kEmbedderDataTypeTagDefault = 0;
 
V8_EXPORT internal::ExternalPointerTag ToExternalPointerTag(
    v8::EmbedderDataTypeTag api_tag);
 
class V8_EXPORT Private : public Data {
 public:
  Local<Value> Name() const;
 
  static Local<Private> New(Isolate* isolate,
                            Local<String> name = Local<String>());
 
  static Local<Private> ForApi(Isolate* isolate, Local<String> name);
 
  V8_INLINE static Private* Cast(Data* data);
 
 private:
  Private();
 
  static void CheckCast(Data* that);
};
 
class V8_EXPORT PropertyDescriptor {
 public:
  // GenericDescriptor
  PropertyDescriptor();
 
  // DataDescriptor
  explicit PropertyDescriptor(Local<Value> value);
 
  // DataDescriptor with writable property
  PropertyDescriptor(Local<Value> value, bool writable);
 
  // AccessorDescriptor
  PropertyDescriptor(Local<Value> get, Local<Value> set);
 
  ~PropertyDescriptor();
 
  Local<Value> value() const;
  bool has_value() const;
 
  Local<Value> get() const;
  bool has_get() const;
  Local<Value> set() const;
  bool has_set() const;
 
  void set_enumerable(bool enumerable);
  bool enumerable() const;
  bool has_enumerable() const;
 
  void set_configurable(bool configurable);
  bool configurable() const;
  bool has_configurable() const;
 
  bool writable() const;
  bool has_writable() const;
 
  struct PrivateData;
  PrivateData* get_private() const { return private_; }
 
  PropertyDescriptor(const PropertyDescriptor&) = delete;
  void operator=(const PropertyDescriptor&) = delete;
 
 private:
  PrivateData* private_;
};
 
enum PropertyAttribute {
  None = 0,
  ReadOnly = 1 << 0,
  DontEnum = 1 << 1,
  DontDelete = 1 << 2
};
 
using AccessorNameGetterCallback =
    void (*)(Local<Name> property, const PropertyCallbackInfo<Value>& info);
 
using AccessorNameSetterCallbackV2 =
    void (*)(Local<Name> property, Local<Value> value,
             const PropertyCallbackInfo<Boolean>& info);
 
enum PropertyFilter {
  ALL_PROPERTIES = 0,
  ONLY_WRITABLE = 1,
  ONLY_ENUMERABLE = 2,
  ONLY_CONFIGURABLE = 4,
  SKIP_STRINGS = 8,
  SKIP_SYMBOLS = 16
};
 
enum class SideEffectType {
  kHasSideEffect,
  kHasNoSideEffect,
  kHasSideEffectToReceiver
};
 
enum class KeyCollectionMode { kOwnOnly, kIncludePrototypes };
 
enum class IndexFilter { kIncludeIndices, kSkipIndices };
 
enum class KeyConversionMode { kConvertToString, kKeepNumbers, kNoNumbers };
 
enum class IntegrityLevel { kFrozen, kSealed };
 
class V8_EXPORT Object : public Value {
 public:
  V8_WARN_UNUSED_RESULT Maybe<bool> Set(Local<Context> context,
                                        Local<Value> key, Local<Value> value);
  V8_WARN_UNUSED_RESULT Maybe<bool> Set(Local<Context> context,
                                        Local<Value> key, Local<Value> value,
                                        MaybeLocal<Object> receiver);
 
  V8_WARN_UNUSED_RESULT Maybe<bool> Set(Local<Context> context, uint32_t index,
                                        Local<Value> value);
 
  V8_WARN_UNUSED_RESULT Maybe<bool> CreateDataProperty(Local<Context> context,
                                                       Local<Name> key,
                                                       Local<Value> value);
  V8_WARN_UNUSED_RESULT Maybe<bool> CreateDataProperty(Local<Context> context,
                                                       uint32_t index,
                                                       Local<Value> value);
 
  V8_WARN_UNUSED_RESULT Maybe<bool> DefineOwnProperty(
      Local<Context> context, Local<Name> key, Local<Value> value,
      PropertyAttribute attributes = None);
 
  V8_WARN_UNUSED_RESULT Maybe<bool> DefineProperty(
      Local<Context> context, Local<Name> key, PropertyDescriptor& descriptor);
 
  V8_WARN_UNUSED_RESULT MaybeLocal<Value> Get(Local<Context> context,
                                              Local<Value> key);
  V8_WARN_UNUSED_RESULT MaybeLocal<Value> Get(Local<Context> context,
                                              Local<Value> key,
                                              MaybeLocal<Object> receiver);
 
  V8_WARN_UNUSED_RESULT MaybeLocal<Value> Get(Local<Context> context,
                                              uint32_t index);
 
  V8_WARN_UNUSED_RESULT MaybeLocal<Value> TryGetWithNoSideEffects(
      Local<Context> context, Local<Name> key);
 
  V8_WARN_UNUSED_RESULT Maybe<PropertyAttribute> GetPropertyAttributes(
      Local<Context> context, Local<Value> key);
  V8_WARN_UNUSED_RESULT Maybe<bool> GetPropertyAttributes(
      Local<Context> context, Local<Value> key,
      PropertyAttribute* out_attributes);
 
  V8_WARN_UNUSED_RESULT MaybeLocal<Value> GetOwnPropertyDescriptor(
      Local<Context> context, Local<Name> key);
 
  V8_WARN_UNUSED_RESULT Maybe<bool> Has(Local<Context> context,
                                        Local<Value> key);
 
  V8_WARN_UNUSED_RESULT Maybe<bool> Delete(Local<Context> context,
                                           Local<Value> key);
 
  V8_WARN_UNUSED_RESULT Maybe<bool> Has(Local<Context> context, uint32_t index);
 
  V8_WARN_UNUSED_RESULT Maybe<bool> Delete(Local<Context> context,
                                           uint32_t index);
 
  void SetAccessorProperty(Local<Name> name, Local<Function> getter,
                           Local<Function> setter = Local<Function>(),
                           PropertyAttribute attributes = None);
 
  V8_WARN_UNUSED_RESULT Maybe<bool> SetNativeDataProperty(
      Local<Context> context, Local<Name> name,
      AccessorNameGetterCallback getter,
      AccessorNameSetterCallbackV2 setter = nullptr,
      Local<Data> data = Local<Data>(), PropertyAttribute attributes = None,
      SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect,
      SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect);
 
  V8_WARN_UNUSED_RESULT Maybe<bool> SetLazyDataProperty(
      Local<Context> context, Local<Name> name,
      AccessorNameGetterCallback getter, Local<Data> data = Local<Data>(),
      PropertyAttribute attributes = None,
      SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect,
      SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect);
 
  Maybe<bool> HasPrivate(Local<Context> context, Local<Private> key);
  Maybe<bool> SetPrivate(Local<Context> context, Local<Private> key,
                         Local<Value> value);
  Maybe<bool> DeletePrivate(Local<Context> context, Local<Private> key);
  MaybeLocal<Value> GetPrivate(Local<Context> context, Local<Private> key);
 
  V8_WARN_UNUSED_RESULT MaybeLocal<Array> GetPropertyNames(
      Local<Context> context);
  V8_WARN_UNUSED_RESULT MaybeLocal<Array> GetPropertyNames(
      Local<Context> context, KeyCollectionMode mode,
      PropertyFilter property_filter, IndexFilter index_filter,
      KeyConversionMode key_conversion = KeyConversionMode::kKeepNumbers);
 
  V8_WARN_UNUSED_RESULT MaybeLocal<Array> GetOwnPropertyNames(
      Local<Context> context);
 
  V8_WARN_UNUSED_RESULT MaybeLocal<Array> GetOwnPropertyNames(
      Local<Context> context, PropertyFilter filter,
      KeyConversionMode key_conversion = KeyConversionMode::kKeepNumbers);
 
  Local<Value> GetPrototype();
 
  V8_WARN_UNUSED_RESULT Maybe<bool> SetPrototype(Local<Context> context,
                                                 Local<Value> prototype);
 
  Local<Object> FindInstanceInPrototypeChain(Local<FunctionTemplate> tmpl);
 
  V8_WARN_UNUSED_RESULT MaybeLocal<String> ObjectProtoToString(
      Local<Context> context);
 
  Local<String> GetConstructorName();
 
  Maybe<bool> SetIntegrityLevel(Local<Context> context, IntegrityLevel level);
 
  int InternalFieldCount() const;
 
  V8_INLINE static int InternalFieldCount(
      const PersistentBase<Object>& object) {
    return object.template value<Object>()->InternalFieldCount();
  }
 
  V8_INLINE static int InternalFieldCount(
      const BasicTracedReference<Object>& object) {
    return object.template value<Object>()->InternalFieldCount();
  }
 
  V8_INLINE Local<Data> GetInternalField(int index);
 
  void SetInternalField(int index, Local<Data> data);
 
  V8_INLINE void* GetAlignedPointerFromInternalField(int index,
                                                     EmbedderDataTypeTag tag);
  V8_INLINE void* GetAlignedPointerFromInternalField(v8::Isolate* isolate,
                                                     int index,
                                                     EmbedderDataTypeTag tag);
 
  template <typename T>
    requires cppgc::IsGarbageCollectedTypeV<T>
  V8_INLINE T* GetPointerFromInternalField(v8::Isolate* isolate, int index,
                                           CppHeapPointerTag tag);
 
  V8_INLINE static void* GetAlignedPointerFromInternalField(
      const PersistentBase<Object>& object, int index,
      EmbedderDataTypeTag tag) {
    return object.template value<Object>()->GetAlignedPointerFromInternalField(
        index, tag);
  }
  template <typename T>
    requires cppgc::IsGarbageCollectedTypeV<T>
  V8_INLINE static T* GetPointerFromInternalField(
      v8::Isolate* isolate, const PersistentBase<Object>& object, int index,
      CppHeapPointerTag tag) {
    return object.template value<Object>()->GetPointerFromInternalField<T>(
        isolate, index, tag);
  }
 
  V8_INLINE static void* GetAlignedPointerFromInternalField(
      const BasicTracedReference<Object>& object, int index,
      EmbedderDataTypeTag tag) {
    return object.template value<Object>()->GetAlignedPointerFromInternalField(
        index, tag);
  }
  template <typename T>
    requires cppgc::IsGarbageCollectedTypeV<T>
  V8_INLINE static T* GetPointerFromInternalField(
      v8::Isolate* isolate, const BasicTracedReference<Object>& object,
      int index, CppHeapPointerTag tag) {
    return object.template value<Object>()->GetPointerFromInternalField<T>(
        isolate, index, tag);
  }
 
  void SetAlignedPointerInInternalField(int index, void* value,
                                        EmbedderDataTypeTag tag);
 
  template <typename T>
    requires(!std::is_void_v<T>) && cppgc::IsGarbageCollectedTypeV<T>
  void SetPointerInInternalField(int index, T* value, CppHeapPointerTag tag) {
    SetPointerInInternalFieldInternal(index, static_cast<void*>(value), tag);
  }
 
  // Type information for a Wrappable object that got wrapped with
  // `v8::Object::Wrap()`.
  struct WrapperTypeInfo {
    const int16_t type_id;
  };
 
  // v8::Object::Wrappable serves as the base class for all C++ objects that can
  // be wrapped by a JavaScript object using `v8::Object::Wrap()`.
  //
  // Note that v8::Object::Wrappable` inherits from `NameProvider` and provides
  // `GetWrapperTypeInfo` to allow subclasses to have smaller object sizes.
  class Wrappable : public cppgc::GarbageCollected<Wrappable>,
                    public cppgc::NameProvider {
   public:
    virtual const WrapperTypeInfo* GetWrapperTypeInfo() const {
      return nullptr;
    }
 
    const char* GetHumanReadableName() const override { return "internal"; }
 
    virtual void Trace(cppgc::Visitor* visitor) const {}
  };
 
  template <CppHeapPointerTag tag, typename T = void>
  static V8_INLINE T* Unwrap(v8::Isolate* isolate,
                             const v8::Local<v8::Object>& wrapper);
  template <CppHeapPointerTag tag, typename T = void>
  static V8_INLINE T* Unwrap(v8::Isolate* isolate,
                             const PersistentBase<Object>& wrapper);
  template <CppHeapPointerTag tag, typename T = void>
  static V8_INLINE T* Unwrap(v8::Isolate* isolate,
                             const BasicTracedReference<Object>& wrapper);
 
  template <typename T = void>
  static V8_INLINE T* Unwrap(v8::Isolate* isolate,
                             const v8::Local<v8::Object>& wrapper,
                             CppHeapPointerTagRange tag_range);
  template <typename T = void>
  static V8_INLINE T* Unwrap(v8::Isolate* isolate,
                             const PersistentBase<Object>& wrapper,
                             CppHeapPointerTagRange tag_range);
  template <typename T = void>
  static V8_INLINE T* Unwrap(v8::Isolate* isolate,
                             const BasicTracedReference<Object>& wrapper,
                             CppHeapPointerTagRange tag_range);
 
  template <CppHeapPointerTag tag>
  static V8_INLINE void Wrap(v8::Isolate* isolate,
                             const v8::Local<v8::Object>& wrapper,
                             Wrappable* wrappable);
  template <CppHeapPointerTag tag>
  static V8_INLINE void Wrap(v8::Isolate* isolate,
                             const PersistentBase<Object>& wrapper,
                             Wrappable* wrappable);
  template <CppHeapPointerTag tag>
  static V8_INLINE void Wrap(v8::Isolate* isolate,
                             const BasicTracedReference<Object>& wrapper,
                             Wrappable* wrappable);
  static V8_INLINE void Wrap(v8::Isolate* isolate,
                             const v8::Local<v8::Object>& wrapper,
                             Wrappable* wrappable, CppHeapPointerTag tag);
  static V8_INLINE void Wrap(v8::Isolate* isolate,
                             const PersistentBase<Object>& wrapper,
                             Wrappable* wrappable, CppHeapPointerTag tag);
  static V8_INLINE void Wrap(v8::Isolate* isolate,
                             const BasicTracedReference<Object>& wrapper,
                             Wrappable* wrappable, CppHeapPointerTag tag);
 
  // Version of Wrap() function for v8::Context::Global() objects.
  // Unlike the functions above it wraps both JSGlobalProxy and its hidden
  // prototype (JSGlobalObject or remote object).
  static void WrapGlobal(v8::Isolate* isolate,
                         const v8::Local<v8::Object>& wrapper,
                         Wrappable* wrappable, CppHeapPointerTag tag);
 
  // Checks that wrappables set on JSGlobalProxy and its hidden prototype are
  // the same.
  static bool CheckGlobalWrappable(v8::Isolate* isolate,
                                   const v8::Local<v8::Object>& wrapper,
                                   CppHeapPointerTagRange tag_range);
 
  V8_WARN_UNUSED_RESULT Maybe<bool> HasOwnProperty(Local<Context> context,
                                                   Local<Name> key);
  V8_WARN_UNUSED_RESULT Maybe<bool> HasOwnProperty(Local<Context> context,
                                                   uint32_t index);
  V8_WARN_UNUSED_RESULT Maybe<bool> HasRealNamedProperty(Local<Context> context,
                                                         Local<Name> key);
  V8_WARN_UNUSED_RESULT Maybe<bool> HasRealIndexedProperty(
      Local<Context> context, uint32_t index);
  V8_WARN_UNUSED_RESULT Maybe<bool> HasRealNamedCallbackProperty(
      Local<Context> context, Local<Name> key);
 
  V8_WARN_UNUSED_RESULT MaybeLocal<Value> GetRealNamedPropertyInPrototypeChain(
      Local<Context> context, Local<Name> key);
 
  V8_WARN_UNUSED_RESULT Maybe<PropertyAttribute>
  GetRealNamedPropertyAttributesInPrototypeChain(Local<Context> context,
                                                 Local<Name> key);
 
  V8_WARN_UNUSED_RESULT MaybeLocal<Value> GetRealNamedProperty(
      Local<Context> context, Local<Name> key);
 
  V8_WARN_UNUSED_RESULT Maybe<PropertyAttribute> GetRealNamedPropertyAttributes(
      Local<Context> context, Local<Name> key);
 
  bool HasNamedLookupInterceptor() const;
 
  bool HasIndexedLookupInterceptor() const;
 
  int GetIdentityHash();
 
  Local<Object> Clone(v8::Isolate* isolate);
  Local<Object> Clone();
 
  MaybeLocal<Context> GetCreationContext(v8::Isolate* isolate);
  V8_DEPRECATE_SOON("Use the version with the isolate argument.")
  MaybeLocal<Context> GetCreationContext();
 
  Local<Context> GetCreationContextChecked(v8::Isolate* isolate);
  V8_DEPRECATE_SOON("Use the version with the isolate argument.")
  Local<Context> GetCreationContextChecked();
 
  V8_INLINE static MaybeLocal<Context> GetCreationContext(
      v8::Isolate* isolate, const PersistentBase<Object>& object) {
    return object.template value<Object>()->GetCreationContext(isolate);
  }
  V8_DEPRECATE_SOON("Use the version with the isolate argument.")
  V8_INLINE static MaybeLocal<Context> GetCreationContext(
      const PersistentBase<Object>& object);
 
  void* GetAlignedPointerFromEmbedderDataInCreationContext(
      v8::Isolate* isolate, int index, EmbedderDataTypeTag tag);
  void* GetAlignedPointerFromEmbedderDataInCreationContext(
      int index, EmbedderDataTypeTag tag);
 
  void* GetAlignedPointerFromEmbedderDataInCreationContext(
      v8::Isolate* isolate, int index, CppHeapPointerTag tag);
  bool IsCallable() const;
 
  bool IsConstructor() const;
 
  bool IsApiWrapper() const;
 
  bool IsUndetectable() const;
 
  V8_WARN_UNUSED_RESULT MaybeLocal<Value> CallAsFunction(Local<Context> context,
                                                         Local<Value> recv,
                                                         int argc,
                                                         Local<Value> argv[]);
 
  V8_WARN_UNUSED_RESULT MaybeLocal<Value> CallAsConstructor(
      Local<Context> context, int argc, Local<Value> argv[]);
 
  MaybeLocal<Array> PreviewEntries(bool* is_key_value);
 
  static Local<Object> New(Isolate* isolate);
 
  static Local<Object> New(Isolate* isolate, Local<Value> prototype_or_null,
                           Local<Name>* names, Local<Value>* values,
                           size_t length);
 
  V8_INLINE static Object* Cast(Value* obj);
 
  bool IsCodeLike(Isolate* isolate) const;
 
 private:
  static void* Unwrap(v8::Isolate* isolate, internal::Address wrapper_obj,
                      CppHeapPointerTagRange tag_range);
  static void Wrap(v8::Isolate* isolate, internal::Address wrapper_obj,
                   CppHeapPointerTag tag, void* wrappable);
 
  Object();
  static void CheckCast(Value* obj);
  Local<Data> SlowGetInternalField(int index);
  void* SlowGetAlignedPointerFromInternalField(int index,
                                               EmbedderDataTypeTag tag);
  void* SlowGetAlignedPointerFromInternalField(v8::Isolate* isolate, int index,
                                               EmbedderDataTypeTag tag);
  void* SlowGetPointerFromInternalField(v8::Isolate* isolate, int index,
                                        CppHeapPointerTag tag);
  void SetPointerInInternalFieldInternal(int index, void* value,
                                         CppHeapPointerTag tag);
};
 
// --- Implementation ---
 
Local<Data> Object::GetInternalField(int index) {
#ifndef V8_ENABLE_CHECKS
  using A = internal::Address;
  using I = internal::Internals;
  A obj = internal::ValueHelper::ValueAsAddress(this);
  // Fast path: If the object is a plain JSObject, which is the common case, we
  // know where to find the internal fields and can return the value directly.
  int instance_type = I::GetInstanceType(obj);
  if (I::CanHaveInternalField(instance_type)) {
    int offset = I::kJSAPIObjectWithEmbedderSlotsHeaderSize +
                 (I::kEmbedderDataSlotSize * index);
#ifdef V8_COMPRESS_POINTERS
    // The tagged payload lives in the low kTaggedSize half of the slot (at
    // kTaggedPayloadOffset == 0). Read it as a 32-bit field so the correct half
    // is picked on both little and big endian targets. A full width read plus
    // truncation would return the CppHeap pointer half on big endian.
    uint32_t compressed = I::ReadRawField<uint32_t>(obj, offset);
    A value = I::DecompressTaggedField(obj, compressed);
#else
    A value = I::ReadRawField<A>(obj, offset);
#endif
 
    auto* isolate = I::GetCurrentIsolate();
    return Local<Data>::New(isolate, value);
  }
#endif
  return SlowGetInternalField(index);
}
 
void* Object::GetAlignedPointerFromInternalField(v8::Isolate* isolate,
                                                 int index,
                                                 EmbedderDataTypeTag tag) {
  return SlowGetAlignedPointerFromInternalField(isolate, index, tag);
}
 
void* Object::GetAlignedPointerFromInternalField(int index,
                                                 EmbedderDataTypeTag tag) {
  return SlowGetAlignedPointerFromInternalField(index, tag);
}
 
template <typename T>
  requires cppgc::IsGarbageCollectedTypeV<T>
T* Object::GetPointerFromInternalField(v8::Isolate* isolate, int index,
                                       CppHeapPointerTag tag) {
#if !defined(V8_ENABLE_CHECKS)
  using A = internal::Address;
  using I = internal::Internals;
  A obj = internal::ValueHelper::ValueAsAddress(this);
  // Fast path: If the object is a plain JSObject, which is the common case, we
  // know where to find the internal fields and can return the value directly.
  auto instance_type = I::GetInstanceType(obj);
  if (V8_LIKELY(I::CanHaveInternalField(instance_type))) {
    int offset = I::kJSAPIObjectWithEmbedderSlotsHeaderSize +
                 (I::kEmbedderDataSlotSize * index) +
                 I::kEmbedderDataSlotCppHeapPointerOffset;
    return internal::ReadCppHeapPointerField<T>(
        isolate, obj, offset, CppHeapPointerTagRange(tag, tag));
  }
#endif
  return static_cast<T*>(SlowGetPointerFromInternalField(isolate, index, tag));
}
 
// static
template <CppHeapPointerTag tag, typename T>
T* Object::Unwrap(v8::Isolate* isolate, const v8::Local<v8::Object>& wrapper) {
  CppHeapPointerTagRange tag_range(tag, tag);
  auto obj = internal::ValueHelper::ValueAsAddress(*wrapper);
#if !defined(V8_ENABLE_CHECKS)
  return internal::ReadCppHeapPointerField<T>(
      isolate, obj, internal::Internals::kJSObjectHeaderSize, tag_range);
#else   // defined(V8_ENABLE_CHECKS)
  return reinterpret_cast<T*>(Unwrap(isolate, obj, tag_range));
#endif  // defined(V8_ENABLE_CHECKS)
}
 
// static
template <CppHeapPointerTag tag, typename T>
T* Object::Unwrap(v8::Isolate* isolate, const PersistentBase<Object>& wrapper) {
  CppHeapPointerTagRange tag_range(tag, tag);
  auto obj =
      internal::ValueHelper::ValueAsAddress(wrapper.template value<Object>());
#if !defined(V8_ENABLE_CHECKS)
  return internal::ReadCppHeapPointerField<T>(
      isolate, obj, internal::Internals::kJSObjectHeaderSize, tag_range);
#else   // defined(V8_ENABLE_CHECKS)
  return reinterpret_cast<T*>(Unwrap(isolate, obj, tag_range));
#endif  // defined(V8_ENABLE_CHECKS)
}
 
// static
template <CppHeapPointerTag tag, typename T>
T* Object::Unwrap(v8::Isolate* isolate,
                  const BasicTracedReference<Object>& wrapper) {
  CppHeapPointerTagRange tag_range(tag, tag);
  auto obj =
      internal::ValueHelper::ValueAsAddress(wrapper.template value<Object>());
#if !defined(V8_ENABLE_CHECKS)
  return internal::ReadCppHeapPointerField<T>(
      isolate, obj, internal::Internals::kJSObjectHeaderSize, tag_range);
#else   // defined(V8_ENABLE_CHECKS)
  return reinterpret_cast<T*>(Unwrap(isolate, obj, tag_range));
#endif  // defined(V8_ENABLE_CHECKS)
}
 
// static
template <typename T>
T* Object::Unwrap(v8::Isolate* isolate, const v8::Local<v8::Object>& wrapper,
                  CppHeapPointerTagRange tag_range) {
  auto obj = internal::ValueHelper::ValueAsAddress(*wrapper);
#if !defined(V8_ENABLE_CHECKS)
  return internal::ReadCppHeapPointerField<T>(
      isolate, obj, internal::Internals::kJSObjectHeaderSize, tag_range);
#else   // defined(V8_ENABLE_CHECKS)
  return reinterpret_cast<T*>(Unwrap(isolate, obj, tag_range));
#endif  // defined(V8_ENABLE_CHECKS)
}
 
// static
template <typename T>
T* Object::Unwrap(v8::Isolate* isolate, const PersistentBase<Object>& wrapper,
                  CppHeapPointerTagRange tag_range) {
  auto obj =
      internal::ValueHelper::ValueAsAddress(wrapper.template value<Object>());
#if !defined(V8_ENABLE_CHECKS)
  return internal::ReadCppHeapPointerField<T>(
      isolate, obj, internal::Internals::kJSObjectHeaderSize, tag_range);
#else   // defined(V8_ENABLE_CHECKS)
 
  return reinterpret_cast<T*>(Unwrap(isolate, obj, tag_range));
#endif  // defined(V8_ENABLE_CHECKS)
}
 
// static
template <typename T>
T* Object::Unwrap(v8::Isolate* isolate,
                  const BasicTracedReference<Object>& wrapper,
                  CppHeapPointerTagRange tag_range) {
  auto obj =
      internal::ValueHelper::ValueAsAddress(wrapper.template value<Object>());
#if !defined(V8_ENABLE_CHECKS)
  return internal::ReadCppHeapPointerField<T>(
      isolate, obj, internal::Internals::kJSObjectHeaderSize, tag_range);
#else   // defined(V8_ENABLE_CHECKS)
  return reinterpret_cast<T*>(Unwrap(isolate, obj, tag_range));
#endif  // defined(V8_ENABLE_CHECKS)
}
 
// static
template <CppHeapPointerTag tag>
void Object::Wrap(v8::Isolate* isolate, const v8::Local<v8::Object>& wrapper,
                  v8::Object::Wrappable* wrappable) {
  static_assert(kObjectWrappableTagRange.Contains(tag),
                "CppHeapPointerTag must be within kObjectWrappableTagRange");
  auto obj = internal::ValueHelper::ValueAsAddress(*wrapper);
  Wrap(isolate, obj, tag, wrappable);
}
 
// static
template <CppHeapPointerTag tag>
void Object::Wrap(v8::Isolate* isolate, const PersistentBase<Object>& wrapper,
                  v8::Object::Wrappable* wrappable) {
  static_assert(kObjectWrappableTagRange.Contains(tag),
                "CppHeapPointerTag must be within kObjectWrappableTagRange");
  auto obj =
      internal::ValueHelper::ValueAsAddress(wrapper.template value<Object>());
  Wrap(isolate, obj, tag, wrappable);
}
 
// static
template <CppHeapPointerTag tag>
void Object::Wrap(v8::Isolate* isolate,
                  const BasicTracedReference<Object>& wrapper,
                  v8::Object::Wrappable* wrappable) {
  static_assert(kObjectWrappableTagRange.Contains(tag),
                "CppHeapPointerTag must be within kObjectWrappableTagRange");
  auto obj =
      internal::ValueHelper::ValueAsAddress(wrapper.template value<Object>());
  Wrap(isolate, obj, tag, wrappable);
}
 
// static
void Object::Wrap(v8::Isolate* isolate, const v8::Local<v8::Object>& wrapper,
                  v8::Object::Wrappable* wrappable, CppHeapPointerTag tag) {
  auto obj = internal::ValueHelper::ValueAsAddress(*wrapper);
  Wrap(isolate, obj, tag, wrappable);
}
 
// static
void Object::Wrap(v8::Isolate* isolate, const PersistentBase<Object>& wrapper,
                  v8::Object::Wrappable* wrappable, CppHeapPointerTag tag) {
  auto obj =
      internal::ValueHelper::ValueAsAddress(wrapper.template value<Object>());
  Wrap(isolate, obj, tag, wrappable);
}
 
// static
void Object::Wrap(v8::Isolate* isolate,
                  const BasicTracedReference<Object>& wrapper,
                  v8::Object::Wrappable* wrappable, CppHeapPointerTag tag) {
  auto obj =
      internal::ValueHelper::ValueAsAddress(wrapper.template value<Object>());
  Wrap(isolate, obj, tag, wrappable);
}
 
Private* Private::Cast(Data* data) {
#ifdef V8_ENABLE_CHECKS
  CheckCast(data);
#endif
  return reinterpret_cast<Private*>(data);
}
 
Object* Object::Cast(v8::Value* value) {
#ifdef V8_ENABLE_CHECKS
  CheckCast(value);
#endif
  return static_cast<Object*>(value);
}
 
}  // namespace v8
 
#endif  // INCLUDE_V8_OBJECT_H_