node-linux-arm64 24.10.0 → 25.0.0

package/include/node/v8-local-handle.h

@@ -42,6 +42,7 @@ class BasicTracedReference;
 template <class F>
 class TracedReference;
 
+class ArrayBuffer;
 class Boolean;
 class Context;
 class EscapableHandleScope;
@@ -62,6 +63,8 @@ template <class F>
 class Traced;
 class TypecheckWitness;
 class Utils;
+class Uint32;
+class Value;
 
 namespace debug {
 class ConsoleCallArguments;
@@ -78,6 +81,25 @@ class SamplingHeapProfiler;
 namespace api_internal {
 // Called when ToLocalChecked is called on an empty Local.
 V8_EXPORT void ToLocalEmpty();
+
+#ifdef V8_ENABLE_CHECKS
+template <typename T, typename V = Value>
+void TypeCheckLocal(V* value) {
+  // If `T` does not provide a `Cast` method we cannot check anything.
+  if constexpr (requires { T::Cast(value); }) {
+    // TODO(419454582): Remove all these exceptions.
+    if (std::is_same_v<Array, T> && value->IsArgumentsObject()) return;
+    if (std::is_same_v<ArrayBuffer, T> && value->IsSharedArrayBuffer()) return;
+    if (std::is_same_v<Object, T> && value->IsNull()) return;
+    if (std::is_same_v<Object, T> && value->IsString()) return;
+    if (std::is_same_v<Object, T> && value->IsUndefined()) return;
+    if (std::is_same_v<Uint32, T> && value->IsInt32()) return;
+    if (std::is_same_v<Object, T> && value->IsNumber()) return;
+    // Execute the actual check (part of the cast).
+    T::Cast(value);
+  }
+}
+#endif
 }  // namespace api_internal
 
 /**
@@ -96,18 +118,16 @@ V8_EXPORT void ToLocalEmpty();
  */
 class V8_EXPORT V8_NODISCARD HandleScope {
  public:
-  explicit HandleScope(Isolate* isolate);
+  V8_INLINE explicit HandleScope(Isolate* isolate);
 
-  ~HandleScope();
+  V8_INLINE ~HandleScope();
 
   /**
    * Counts the number of allocated handles.
    */
   static int NumberOfHandles(Isolate* isolate);
 
-  V8_INLINE Isolate* GetIsolate() const {
-    return reinterpret_cast<Isolate*>(i_isolate_);
-  }
+  V8_INLINE Isolate* GetIsolate() const { return isolate_; }
 
   HandleScope(const HandleScope&) = delete;
   void operator=(const HandleScope&) = delete;
@@ -118,12 +138,29 @@ class V8_EXPORT V8_NODISCARD HandleScope {
  protected:
   V8_INLINE HandleScope() = default;
 
-  void Initialize(Isolate* isolate);
+  V8_INLINE void Initialize(Isolate* isolate);
 
-  static internal::Address* CreateHandle(internal::Isolate* i_isolate,
-                                         internal::Address value);
+  V8_INLINE static internal::Address* CreateHandle(Isolate* i_isolate,
+                                                   internal::Address value);
 
  private:
+  // Extend the HandleScope making room for more handles.  Not inlined.
+  static internal::Address* Extend(Isolate* isolate);
+  // Delete any extensions in HandleScope destructor.  Not called unless there
+  // are extensions.  Not inlined.
+  void DeleteExtensions(Isolate* isolate);
+
+#ifdef V8_ENABLE_CHECKS
+  // Non-inlined asserts on HandleScope constructor.
+  void DoInitializeAsserts(Isolate* isolate);
+  // Non-inlined assert for HandleScope destructor.
+  void AssertScopeLevelsMatch();
+  // Non-inlined asserts for HandleScope destructor.  Also zaps the slots
+  // if this is enabled.
+  void DoCloseScopeAsserts(int before, internal::Address* limit,
+                           internal::HandleScopeData* current);
+#endif
+
   // Declaring operator new and delete as deleted is not spec compliant.
   // Therefore declare them private instead to disable dynamic alloc
   void* operator new(size_t size);
@@ -131,7 +168,7 @@ class V8_EXPORT V8_NODISCARD HandleScope {
   void operator delete(void*, size_t);
   void operator delete[](void*, size_t);
 
-  internal::Isolate* i_isolate_;
+  Isolate* isolate_;
   internal::Address* prev_next_;
   internal::Address* prev_limit_;
 #ifdef V8_ENABLE_CHECKS
@@ -148,6 +185,61 @@ class V8_EXPORT V8_NODISCARD HandleScope {
   friend class Context;
 };
 
+HandleScope::HandleScope(Isolate* v8_isolate) { Initialize(v8_isolate); }
+
+void HandleScope::Initialize(Isolate* v8_isolate) {
+  using I = internal::Internals;
+  internal::HandleScopeData* current = I::GetHandleScopeData(v8_isolate);
+  isolate_ = v8_isolate;
+  prev_next_ = current->next;
+  prev_limit_ = current->limit;
+  current->level++;
+#ifdef V8_ENABLE_CHECKS
+  DoInitializeAsserts(v8_isolate);
+  scope_level_ = current->level;
+#endif
+}
+
+HandleScope::~HandleScope() {
+  if (V8_UNLIKELY(isolate_ == nullptr)) return;
+#ifdef V8_ENABLE_CHECKS
+  AssertScopeLevelsMatch();
+  int handle_count_before = NumberOfHandles(isolate_);
+#endif
+
+  using I = internal::Internals;
+  internal::HandleScopeData* current = I::GetHandleScopeData(isolate_);
+  std::swap(current->next, prev_next_);
+  current->level--;
+  internal::Address* limit = prev_next_;
+  if (V8_UNLIKELY(current->limit != prev_limit_)) {
+    current->limit = prev_limit_;
+    limit = prev_limit_;
+    DeleteExtensions(isolate_);
+  }
+#ifdef V8_ENABLE_CHECKS
+  DoCloseScopeAsserts(handle_count_before, limit, current);
+#else
+  (void)limit;  // Avoid unused variable warning.
+#endif
+}
+
+internal::Address* HandleScope::CreateHandle(Isolate* v8_isolate,
+                                             internal::Address value) {
+  using I = internal::Internals;
+  internal::HandleScopeData* data = I::GetHandleScopeData(v8_isolate);
+  internal::Address* result = data->next;
+  if (V8_UNLIKELY(result == data->limit)) {
+    result = Extend(v8_isolate);
+  }
+  // Update the current next field, set the value in the created handle,
+  // and return the result.
+  data->next = reinterpret_cast<internal::Address*>(
+      reinterpret_cast<internal::Address>(result) + sizeof(internal::Address));
+  *result = value;
+  return result;
+}
+
 /**
  * A base class for local handles.
  * Its implementation depends on whether direct handle support is enabled.
@@ -164,7 +256,11 @@ class LocalBase : public api_internal::DirectHandleBase {
 
   V8_INLINE LocalBase() = default;
 
-  V8_INLINE explicit LocalBase(internal::Address ptr) : DirectHandleBase(ptr) {}
+  V8_INLINE explicit LocalBase(internal::Address ptr) : DirectHandleBase(ptr) {
+#ifdef V8_ENABLE_CHECKS
+    if (!IsEmpty()) api_internal::TypeCheckLocal<T>(value<Value>());
+#endif
+  }
 
   template <typename S>
   V8_INLINE LocalBase(const LocalBase<S>& other) : DirectHandleBase(other) {}
@@ -200,14 +296,17 @@ class LocalBase : public api_internal::IndirectHandleBase {
   V8_INLINE LocalBase() = default;
 
   V8_INLINE explicit LocalBase(internal::Address* location)
-      : IndirectHandleBase(location) {}
+      : IndirectHandleBase(location) {
+#ifdef V8_ENABLE_CHECKS
+    if (!IsEmpty()) api_internal::TypeCheckLocal<T>(value<Value>());
+#endif
+  }
 
   template <typename S>
   V8_INLINE LocalBase(const LocalBase<S>& other) : IndirectHandleBase(other) {}
 
   V8_INLINE static LocalBase<T> New(Isolate* isolate, internal::Address value) {
-    return LocalBase(HandleScope::CreateHandle(
-        reinterpret_cast<internal::Isolate*>(isolate), value));
+    return LocalBase(HandleScope::CreateHandle(isolate, value));
   }
 
   V8_INLINE static LocalBase<T> New(Isolate* isolate, T* that) {

package/include/node/v8-maybe.h

@@ -14,6 +14,12 @@
 
 namespace v8 {
 
+namespace internal {
+struct NullMaybeType {};
+
+constexpr NullMaybeType kNullMaybe;
+}  // namespace internal
+
 namespace api_internal {
 // Called when ToChecked is called on an empty Maybe.
 V8_EXPORT void FromJustIsNothing();
@@ -32,9 +38,19 @@ V8_EXPORT void FromJustIsNothing();
 template <class T>
 class Maybe : public cppgc::internal::ConditionalStackAllocatedBase<T> {
  public:
+  constexpr Maybe() = default;
+
+  V8_INLINE Maybe(internal::NullMaybeType) {}
+
   V8_INLINE bool IsNothing() const { return !has_value_; }
   V8_INLINE bool IsJust() const { return has_value_; }
 
+  /**
+   * Same as IsNothing(). It's useful for unified handling of empty states
+   * with v8::MaybeLocal<T>.
+   */
+  V8_INLINE bool IsEmpty() const { return IsNothing(); }
+
   /**
    * An alias for |FromJust|. Will crash if the Maybe<> is nothing.
    */
@@ -57,6 +73,16 @@ class Maybe : public cppgc::internal::ConditionalStackAllocatedBase<T> {
     return IsJust();
   }
 
+  /**
+   * Converts this Maybe<> to a value of type T, moving out of it. If this
+   * Maybe<> is nothing (empty), |false| is returned and |out| is left
+   * untouched.
+   */
+  V8_WARN_UNUSED_RESULT V8_INLINE bool MoveTo(T* out) && {
+    if (V8_LIKELY(IsJust())) *out = std::move(value_);
+    return IsJust();
+  }
+
   /**
    * Converts this Maybe<> to a value of type T. If this Maybe<> is
    * nothing (empty), V8 will crash the process.
@@ -93,15 +119,12 @@ class Maybe : public cppgc::internal::ConditionalStackAllocatedBase<T> {
   }
 
  private:
-  Maybe() : has_value_(false) {}
   explicit Maybe(const T& t) : has_value_(true), value_(t) {}
   explicit Maybe(T&& t) : has_value_(true), value_(std::move(t)) {}
 
-  bool has_value_;
+  bool has_value_ = false;
   T value_;
 
-  template <class U>
-  friend Maybe<U> Nothing();
   template <class U>
   friend Maybe<U> Just(const U& u);
   template <class U, std::enable_if_t<!std::is_lvalue_reference_v<U>>*>
@@ -109,8 +132,8 @@ class Maybe : public cppgc::internal::ConditionalStackAllocatedBase<T> {
 };
 
 template <class T>
-inline Maybe<T> Nothing() {
-  return Maybe<T>();
+inline constexpr Maybe<T> Nothing() {
+  return {};
 }
 
 template <class T>
@@ -130,7 +153,11 @@ inline Maybe<T> Just(T&& t) {
 template <>
 class Maybe<void> {
  public:
+  constexpr Maybe() = default;
+  constexpr Maybe(internal::NullMaybeType) {}
+
   V8_INLINE bool IsNothing() const { return !is_valid_; }
+  V8_INLINE bool IsEmpty() const { return IsNothing(); }
   V8_INLINE bool IsJust() const { return is_valid_; }
 
   V8_INLINE bool operator==(const Maybe& other) const {
@@ -144,13 +171,10 @@ class Maybe<void> {
  private:
   struct JustTag {};
 
-  Maybe() : is_valid_(false) {}
   explicit Maybe(JustTag) : is_valid_(true) {}
 
-  bool is_valid_;
+  bool is_valid_ = false;
 
-  template <class U>
-  friend Maybe<U> Nothing();
   friend Maybe<void> JustVoid();
 };
 

package/include/node/v8-memory-span.h

@@ -87,15 +87,20 @@ class V8_EXPORT MemorySpan {
   static constexpr bool is_compatible_iterator_v =
       is_compatible_iterator<It>::value;
 
+  // SFINAE-compatible wrapper for `std::to_address()`.
+  // Adapted from "base/types/to_address.h" in chromium.
   template <typename U>
+    requires(!std::is_function_v<U>)
   [[nodiscard]] static constexpr U* to_address(U* p) noexcept {
     return p;
   }
 
-  template <typename It,
-            typename = std::void_t<decltype(std::declval<It&>().operator->())>>
-  [[nodiscard]] static constexpr auto to_address(It it) noexcept {
-    return it.operator->();
+  template <typename It>
+    requires(
+        requires(const It& it) { std::pointer_traits<It>::to_address(it); } ||
+        requires(const It& it) { it.operator->(); })
+  [[nodiscard]] static constexpr auto to_address(const It& it) noexcept {
+    return std::to_address(it);
   }
 
  public:

package/include/node/v8-message.h

@@ -111,6 +111,9 @@ class V8_EXPORT Message {
   /**
    * Return the isolate to which the Message belongs.
    */
+  V8_DEPRECATED(
+      "Use Isolate::GetCurrent() instead, which is guaranteed to return the "
+      "same isolate since https://crrev.com/c/6458560.")
   Isolate* GetIsolate() const;
 
   V8_WARN_UNUSED_RESULT MaybeLocal<String> GetSource(

package/include/node/v8-object.h

@@ -5,6 +5,8 @@
 #ifndef INCLUDE_V8_OBJECT_H_
 #define INCLUDE_V8_OBJECT_H_
 
+#include "cppgc/garbage-collected.h"
+#include "cppgc/name-provider.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)
@@ -23,6 +25,14 @@ class FunctionTemplate;
 template <typename T>
 class PropertyCallbackInfo;
 
+/**
+ * A tag for embedder data. Objects with different C++ types should use
+ * different values of EmbedderDataTypeTag when written to embedder data. The
+ * allowed range is 0..V8_EMBEDDER_DATA_TAG_COUNT - 1. If this is not
+ * sufficient, V8_EMBEDDER_DATA_TAG_COUNT can be increased.
+ */
+using EmbedderDataTypeTag = uint16_t;
+
 /**
  * A private symbol
  *
@@ -427,15 +437,15 @@ class V8_EXPORT Object : public Value {
    * be skipped by __proto__ and it does not consult the security
    * handler.
    */
-  V8_DEPRECATE_SOON(
+  V8_DEPRECATED(
       "V8 will stop providing access to hidden prototype (i.e. "
       "JSGlobalObject). Use GetPrototypeV2() instead. "
       "See http://crbug.com/333672197.")
   Local<Value> GetPrototype();
 
   /**
-   * Get the prototype object (same as getting __proto__ property).  This does
-   * not consult the security handler.
+   * Get the prototype object (same as calling Object.getPrototypeOf(..)).
+   * This does not consult the security handler.
    * TODO(333672197): rename back to GetPrototype() once the old version goes
    * through the deprecation process and is removed.
    */
@@ -446,7 +456,7 @@ class V8_EXPORT Object : public Value {
    * be skipped by __proto__ and it does not consult the security
    * handler.
    */
-  V8_DEPRECATE_SOON(
+  V8_DEPRECATED(
       "V8 will stop providing access to hidden prototype (i.e. "
       "JSGlobalObject). Use SetPrototypeV2() instead. "
       "See http://crbug.com/333672197.")
@@ -454,8 +464,8 @@ class V8_EXPORT Object : public Value {
                                                  Local<Value> prototype);
 
   /**
-   * Set the prototype object (same as setting __proto__ property).  This does
-   * does not consult the security handler.
+   * Set the prototype object (same as calling Object.setPrototypeOf(..)).
+   * This does not consult the security handler.
    * TODO(333672197): rename back to SetPrototype() once the old version goes
    * through the deprecation process and is removed.
    */
@@ -544,10 +554,43 @@ class V8_EXPORT Object : public Value {
    * a field, GetAlignedPointerFromInternalField must be used, everything else
    * leads to undefined behavior.
    */
+  V8_DEPRECATE_SOON(
+      "Use SetAlignedPointerInInternalField with EmbedderDataTypeTag parameter "
+      "instead.")
   void SetAlignedPointerInInternalField(int index, void* value);
+
+  void SetAlignedPointerInInternalField(int index, void* value,
+                                        EmbedderDataTypeTag tag);
+
+  V8_DEPRECATE_SOON(
+      "Use SetAlignedPointerInInternalField with EmbedderDataTypeTag "
+      "parameter instead.")
   void SetAlignedPointerInInternalFields(int argc, int indices[],
                                          void* values[]);
 
+  // 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 {}
+  };
+
   /**
    * Unwraps a JS wrapper object.
    *
@@ -593,24 +636,37 @@ class V8_EXPORT Object : public Value {
   template <CppHeapPointerTag tag>
   static V8_INLINE void Wrap(v8::Isolate* isolate,
                              const v8::Local<v8::Object>& wrapper,
-                             void* wrappable);
+                             Wrappable* wrappable);
   template <CppHeapPointerTag tag>
   static V8_INLINE void Wrap(v8::Isolate* isolate,
                              const PersistentBase<Object>& wrapper,
-                             void* wrappable);
+                             Wrappable* wrappable);
   template <CppHeapPointerTag tag>
   static V8_INLINE void Wrap(v8::Isolate* isolate,
                              const BasicTracedReference<Object>& wrapper,
-                             void* wrappable);
+                             Wrappable* wrappable);
   static V8_INLINE void Wrap(v8::Isolate* isolate,
                              const v8::Local<v8::Object>& wrapper,
-                             void* wrappable, CppHeapPointerTag tag);
+                             Wrappable* wrappable, CppHeapPointerTag tag);
   static V8_INLINE void Wrap(v8::Isolate* isolate,
                              const PersistentBase<Object>& wrapper,
-                             void* wrappable, CppHeapPointerTag tag);
+                             Wrappable* wrappable, CppHeapPointerTag tag);
   static V8_INLINE void Wrap(v8::Isolate* isolate,
                              const BasicTracedReference<Object>& wrapper,
-                             void* wrappable, CppHeapPointerTag tag);
+                             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);
 
   /**
    * HasOwnProperty() is like JavaScript's
@@ -795,8 +851,14 @@ class V8_EXPORT Object : public Value {
   /**
    * Return the isolate to which the Object belongs to.
    */
+  V8_DEPRECATED(
+      "Use Isolate::GetCurrent() instead, which is guaranteed to return the "
+      "same isolate since https://crrev.com/c/6458560.")
   Isolate* GetIsolate();
 
+  V8_DEPRECATED(
+      "Use Isolate::GetCurrent() instead, which is guaranteed to return the "
+      "same isolate since https://crrev.com/c/6458560.")
   V8_INLINE static Isolate* GetIsolate(const TracedReference<Object>& handle) {
     return handle.template value<Object>()->GetIsolate();
   }
@@ -871,8 +933,7 @@ Local<Data> Object::GetInternalField(int index) {
     value = I::DecompressTaggedField(obj, static_cast<uint32_t>(value));
 #endif
 
-    auto isolate = reinterpret_cast<v8::Isolate*>(
-        internal::IsolateFromNeverReadOnlySpaceObject(obj));
+    auto* isolate = I::GetCurrentIsolate();
     return Local<Data>::New(isolate, value);
   }
 #endif
@@ -893,7 +954,8 @@ void* Object::GetAlignedPointerFromInternalField(v8::Isolate* isolate,
                  (I::kEmbedderDataSlotSize * index) +
                  I::kEmbedderDataSlotExternalPointerOffset;
     A value =
-        I::ReadExternalPointerField<internal::kEmbedderDataSlotPayloadTag>(
+        I::ReadExternalPointerField<{internal::kFirstEmbedderDataTag,
+                                     internal::kLastEmbedderDataTag}>(
             isolate, obj, offset);
     return reinterpret_cast<void*>(value);
   }
@@ -913,9 +975,10 @@ void* Object::GetAlignedPointerFromInternalField(int index) {
     int offset = I::kJSAPIObjectWithEmbedderSlotsHeaderSize +
                  (I::kEmbedderDataSlotSize * index) +
                  I::kEmbedderDataSlotExternalPointerOffset;
-    Isolate* isolate = I::GetIsolateForSandbox(obj);
+    Isolate* isolate = I::GetCurrentIsolateForSandbox();
     A value =
-        I::ReadExternalPointerField<internal::kEmbedderDataSlotPayloadTag>(
+        I::ReadExternalPointerField<{internal::kFirstEmbedderDataTag,
+                                     internal::kLastEmbedderDataTag}>(
             isolate, obj, offset);
     return reinterpret_cast<void*>(value);
   }
@@ -1011,7 +1074,7 @@ T* Object::Unwrap(v8::Isolate* isolate,
 // static
 template <CppHeapPointerTag tag>
 void Object::Wrap(v8::Isolate* isolate, const v8::Local<v8::Object>& wrapper,
-                  void* wrappable) {
+                  v8::Object::Wrappable* wrappable) {
   auto obj = internal::ValueHelper::ValueAsAddress(*wrapper);
   Wrap(isolate, obj, tag, wrappable);
 }
@@ -1019,7 +1082,7 @@ void Object::Wrap(v8::Isolate* isolate, const v8::Local<v8::Object>& wrapper,
 // static
 template <CppHeapPointerTag tag>
 void Object::Wrap(v8::Isolate* isolate, const PersistentBase<Object>& wrapper,
-                  void* wrappable) {
+                  v8::Object::Wrappable* wrappable) {
   auto obj =
       internal::ValueHelper::ValueAsAddress(wrapper.template value<Object>());
   Wrap(isolate, obj, tag, wrappable);
@@ -1029,7 +1092,7 @@ void Object::Wrap(v8::Isolate* isolate, const PersistentBase<Object>& wrapper,
 template <CppHeapPointerTag tag>
 void Object::Wrap(v8::Isolate* isolate,
                   const BasicTracedReference<Object>& wrapper,
-                  void* wrappable) {
+                  v8::Object::Wrappable* wrappable) {
   auto obj =
       internal::ValueHelper::ValueAsAddress(wrapper.template value<Object>());
   Wrap(isolate, obj, tag, wrappable);
@@ -1037,14 +1100,14 @@ void Object::Wrap(v8::Isolate* isolate,
 
 // static
 void Object::Wrap(v8::Isolate* isolate, const v8::Local<v8::Object>& wrapper,
-                  void* wrappable, CppHeapPointerTag tag) {
+                  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,
-                  void* wrappable, CppHeapPointerTag tag) {
+                  v8::Object::Wrappable* wrappable, CppHeapPointerTag tag) {
   auto obj =
       internal::ValueHelper::ValueAsAddress(wrapper.template value<Object>());
   Wrap(isolate, obj, tag, wrappable);
@@ -1052,8 +1115,8 @@ void Object::Wrap(v8::Isolate* isolate, const PersistentBase<Object>& wrapper,
 
 // static
 void Object::Wrap(v8::Isolate* isolate,
-                  const BasicTracedReference<Object>& wrapper, void* wrappable,
-                  CppHeapPointerTag tag) {
+                  const BasicTracedReference<Object>& wrapper,
+                  v8::Object::Wrappable* wrappable, CppHeapPointerTag tag) {
   auto obj =
       internal::ValueHelper::ValueAsAddress(wrapper.template value<Object>());
   Wrap(isolate, obj, tag, wrappable);

package/include/node/v8-persistent-handle.h

@@ -431,7 +431,7 @@ internal::Address* PersistentBase<T>::New(Isolate* isolate, T* that) {
 template <class T, class M>
 template <class S, class M2>
 void Persistent<T, M>::Copy(const Persistent<S, M2>& that) {
-  static_assert(std::is_base_of<T, S>::value, "type check");
+  static_assert(std::is_base_of_v<T, S>, "type check");
   this->Reset();
   if (that.IsEmpty()) return;
   this->slot() = api_internal::CopyGlobalReference(that.slot());
@@ -459,7 +459,7 @@ void PersistentBase<T>::Reset() {
 template <class T>
 template <class S>
 void PersistentBase<T>::Reset(Isolate* isolate, const Local<S>& other) {
-  static_assert(std::is_base_of<T, S>::value, "type check");
+  static_assert(std::is_base_of_v<T, S>, "type check");
   Reset();
   if (other.IsEmpty()) return;
   this->slot() = New(isolate, *other);
@@ -473,7 +473,7 @@ template <class T>
 template <class S>
 void PersistentBase<T>::Reset(Isolate* isolate,
                               const PersistentBase<S>& other) {
-  static_assert(std::is_base_of<T, S>::value, "type check");
+  static_assert(std::is_base_of_v<T, S>, "type check");
   Reset();
   if (other.IsEmpty()) return;
   this->slot() = New(isolate, other.template value<S>());
@@ -546,7 +546,7 @@ Global<T>::Global(Global&& other) : PersistentBase<T>(other.slot()) {
 template <class T>
 template <class S>
 Global<T>& Global<T>::operator=(Global<S>&& rhs) {
-  static_assert(std::is_base_of<T, S>::value, "type check");
+  static_assert(std::is_base_of_v<T, S>, "type check");
   if (this != &rhs) {
     this->Reset();
     if (!rhs.IsEmpty()) {