node-darwin-x64 25.9.0 → 26.0.0

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

@@ -8,29 +8,14 @@
 #include <stddef.h>
 
 #include <array>
+#include <compare>
 #include <cstddef>
 #include <iterator>
+#include <ranges>
 #include <type_traits>
 
 #include "v8config.h"  // NOLINT(build/include_directory)
 
-// TODO(pkasting): Use <compare>/spaceship unconditionally after dropping
-// support for old libstdc++ versions.
-#if __has_include(<version>)
-#include <version>
-#endif
-#if defined(__cpp_lib_three_way_comparison) && \
-    __cpp_lib_three_way_comparison >= 201711L
-#define V8_HAVE_SPACESHIP_OPERATOR 1
-#else
-#define V8_HAVE_SPACESHIP_OPERATOR 0
-#endif
-
-// TODO(pkasting): Make this block unconditional after dropping support for old
-// libstdc++ versions.
-#if __has_include(<ranges>)
-#include <ranges>
-
 namespace v8 {
 
 template <typename T>
@@ -46,7 +31,6 @@ inline constexpr bool std::ranges::enable_view<v8::MemorySpan<T>> = true;
 template <typename T>
 inline constexpr bool std::ranges::enable_borrowed_range<v8::MemorySpan<T>> =
     true;
-#endif
 
 namespace v8 {
 
@@ -164,52 +148,13 @@ class V8_EXPORT MemorySpan {
     using pointer = value_type*;
     using reference = value_type&;
     using iterator_category = std::random_access_iterator_tag;
-    // There seems to be no feature-test macro covering this, so use the
-    // presence of `<ranges>` as a crude proxy, since it was added to the
-    // standard as part of the Ranges papers.
-    // TODO(pkasting): Add this unconditionally after dropping support for old
-    // libstdc++ versions.
-#if __has_include(<ranges>)
     using iterator_concept = std::contiguous_iterator_tag;
-#endif
 
     // Required to satisfy `std::semiregular<>`.
     constexpr Iterator() = default;
 
-    [[nodiscard]] friend constexpr bool operator==(const Iterator& a,
-                                                   const Iterator& b) {
-      // TODO(pkasting): Replace this body with `= default` after dropping
-      // support for old gcc versions.
-      return a.ptr_ == b.ptr_;
-    }
-#if V8_HAVE_SPACESHIP_OPERATOR
-    [[nodiscard]] friend constexpr auto operator<=>(const Iterator&,
-                                                    const Iterator&) = default;
-#else
-    // Assume that if spaceship isn't present, operator rewriting might not be
-    // either.
-    [[nodiscard]] friend constexpr bool operator!=(const Iterator& a,
-                                                   const Iterator& b) {
-      return a.ptr_ != b.ptr_;
-    }
-
-    [[nodiscard]] friend constexpr bool operator<(const Iterator& a,
-                                                  const Iterator& b) {
-      return a.ptr_ < b.ptr_;
-    }
-    [[nodiscard]] friend constexpr bool operator<=(const Iterator& a,
-                                                   const Iterator& b) {
-      return a.ptr_ <= b.ptr_;
-    }
-    [[nodiscard]] friend constexpr bool operator>(const Iterator& a,
-                                                  const Iterator& b) {
-      return a.ptr_ > b.ptr_;
-    }
-    [[nodiscard]] friend constexpr bool operator>=(const Iterator& a,
-                                                   const Iterator& b) {
-      return a.ptr_ >= b.ptr_;
-    }
-#endif
+    [[nodiscard]] constexpr bool operator==(const Iterator&) const = default;
+    [[nodiscard]] constexpr auto operator<=>(const Iterator&) const = default;
 
     constexpr Iterator& operator++() {
       ++ptr_;

package/include/node/v8-message.h

@@ -108,14 +108,6 @@ class V8_EXPORT Message {
  public:
   Local<String> Get() const;
 
-  /**
-   * 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(
       Local<Context> context) const;
   V8_WARN_UNUSED_RESULT MaybeLocal<String> GetSourceLine(

package/include/node/v8-object.h

@@ -33,6 +33,11 @@ class PropertyCallbackInfo;
  */
 using EmbedderDataTypeTag = uint16_t;
 
+constexpr EmbedderDataTypeTag kEmbedderDataTypeTagDefault = 0;
+
+V8_EXPORT internal::ExternalPointerTag ToExternalPointerTag(
+    v8::EmbedderDataTypeTag api_tag);
+
 /**
  * A private symbol
  *
@@ -158,30 +163,44 @@ enum PropertyAttribute {
 };
 
 /**
- * Accessor[Getter|Setter] are used as callback functions when setting|getting
- * a particular data property. See Object::SetNativeDataProperty and
+ * This callback function is called when getting a particular data property
+ * (i.e. when performing [[Get]] operation).
+ *
+ * The callback returns the result by calling `info.GetReturnValue().Set(..)`.
+ *
+ * \param property The name of the property being requested.
+ * \param info Information about the intercepted request, such as
+ * isolate, object holding the property, return value. See
+ * `PropertyCallbackInfo`.
+ *
+ * See Object::SetNativeDataProperty and
  * ObjectTemplate::SetNativeDataProperty methods.
  */
 using AccessorNameGetterCallback =
     void (*)(Local<Name> property, const PropertyCallbackInfo<Value>& info);
 
-using AccessorNameSetterCallback =
-    void (*)(Local<Name> property, Local<Value> value,
-             const PropertyCallbackInfo<void>& info);
-
 /**
- * Access control specifications.
+ * This callback function is called when setting a particular data property
+ * (i.e. when performing [[Set]] operation).
+ *
+ * In case of operation failure the callback should
+ *  - call `info.GetReturnValue().Set(false)`,
+ *  - (optionally) upon operation failure and info.ShouldThrowOnError()
+ *    is true (indicating execution in `'use strict'` mode) the callback can
+ *    throw TypeError if the error message needs to include more details than
+ *    a TypeError thrown by V8 in this case.
  *
- * Some accessors should be accessible across contexts. These
- * accessors have an explicit access control parameter which specifies
- * the kind of cross-context access that should be allowed.
+ * \param property The name of the property being requested.
+ * \param info Information about the intercepted request, such as
+ * isolate, object holding the property, return value, or whether running in
+ * `'use strict'` mode. See `PropertyCallbackInfo`.
  *
+ * See Object::SetNativeDataProperty and
+ * ObjectTemplate::SetNativeDataProperty methods.
  */
-enum V8_DEPRECATE_SOON(
-    "This enum is no longer used and will be removed in V8 12.9.")
-    AccessControl {
-      DEFAULT V8_ENUM_DEPRECATE_SOON("not used") = 0,
-    };
+using AccessorNameSetterCallback =
+    void (*)(Local<Name> property, Local<Value> value,
+             const PropertyCallbackInfo<void>& info);
 
 /**
  * Property filter bits. They can be or'ed to build a composite filter.
@@ -317,9 +336,24 @@ class V8_EXPORT Object : public Value {
    * Gets the property attributes of a property which can be None or
    * any combination of ReadOnly, DontEnum and DontDelete. Returns
    * None when the property doesn't exist.
+   *
+   * This method will be deprecated soon, since it doesn't provide a way
+   * to return "property does not exist" result. Use GetPropertyAttributes with
+   * PropertyAttribute* instead.
    */
   V8_WARN_UNUSED_RESULT Maybe<PropertyAttribute> GetPropertyAttributes(
       Local<Context> context, Local<Value> key);
+  /**
+   * Gets the property attributes of a property which can be None or
+   * any combination of ReadOnly, DontEnum and DontDelete.
+   *
+   * Returns true and sets *out_attributes if the property exists, false if
+   * not or empty Maybe if an exception is thrown. In the latter two cases,
+   * the value of *out_attributes is not modified.
+   */
+  V8_WARN_UNUSED_RESULT Maybe<bool> GetPropertyAttributes(
+      Local<Context> context, Local<Value> key,
+      PropertyAttribute* out_attributes);
 
   /**
    * Implements Object.getOwnPropertyDescriptor(O, P), see
@@ -432,42 +466,17 @@ class V8_EXPORT Object : public Value {
       Local<Context> context, PropertyFilter filter,
       KeyConversionMode key_conversion = KeyConversionMode::kKeepNumbers);
 
-  /**
-   * Get the prototype object.  This does not skip objects marked to
-   * be skipped by __proto__ and it does not consult the security
-   * handler.
-   */
-  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 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.
+   * TODO(http://crbug.com/333672197): rename back to GetPrototype().
    */
   Local<Value> GetPrototypeV2();
 
-  /**
-   * Set the prototype object.  This does not skip objects marked to
-   * be skipped by __proto__ and it does not consult the security
-   * handler.
-   */
-  V8_DEPRECATED(
-      "V8 will stop providing access to hidden prototype (i.e. "
-      "JSGlobalObject). Use SetPrototypeV2() instead. "
-      "See http://crbug.com/333672197.")
-  V8_WARN_UNUSED_RESULT Maybe<bool> SetPrototype(Local<Context> context,
-                                                 Local<Value> prototype);
-
   /**
    * 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.
+   * TODO(http://crbug.com/333672197): rename back to SetPrototype().
    */
   V8_WARN_UNUSED_RESULT Maybe<bool> SetPrototypeV2(Local<Context> context,
                                                    Local<Value> prototype);
@@ -531,22 +540,26 @@ class V8_EXPORT Object : public Value {
    * must have been set by SetAlignedPointerInInternalField, everything else
    * leads to undefined behavior.
    */
-  V8_INLINE void* GetAlignedPointerFromInternalField(int index);
+  V8_INLINE void* GetAlignedPointerFromInternalField(int index,
+                                                     EmbedderDataTypeTag tag);
   V8_INLINE void* GetAlignedPointerFromInternalField(v8::Isolate* isolate,
-                                                     int index);
+                                                     int index,
+                                                     EmbedderDataTypeTag tag);
 
   /** Same as above, but works for PersistentBase. */
   V8_INLINE static void* GetAlignedPointerFromInternalField(
-      const PersistentBase<Object>& object, int index) {
+      const PersistentBase<Object>& object, int index,
+      EmbedderDataTypeTag tag) {
     return object.template value<Object>()->GetAlignedPointerFromInternalField(
-        index);
+        index, tag);
   }
 
   /** Same as above, but works for TracedReference. */
   V8_INLINE static void* GetAlignedPointerFromInternalField(
-      const BasicTracedReference<Object>& object, int index) {
+      const BasicTracedReference<Object>& object, int index,
+      EmbedderDataTypeTag tag) {
     return object.template value<Object>()->GetAlignedPointerFromInternalField(
-        index);
+        index, tag);
   }
 
   /**
@@ -554,20 +567,9 @@ 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 {
@@ -794,10 +796,16 @@ class V8_EXPORT Object : public Value {
    *
    * Prefer using version with Isolate parameter if you have an Isolate,
    * otherwise use the other one.
+   *
+   * The type tag has to match the type tag used for storing the value in the
+   * embedder field.
+   * If type tags are not used in the embedder, the default value
+   * `kEmbedderDataTypeTagDefault` can be used.
    */
-  void* GetAlignedPointerFromEmbedderDataInCreationContext(v8::Isolate* isolate,
-                                                           int index);
-  void* GetAlignedPointerFromEmbedderDataInCreationContext(int index);
+  void* GetAlignedPointerFromEmbedderDataInCreationContext(
+      v8::Isolate* isolate, int index, EmbedderDataTypeTag tag);
+  void* GetAlignedPointerFromEmbedderDataInCreationContext(
+      int index, EmbedderDataTypeTag tag);
 
   /**
    * Checks whether a callback is set by the
@@ -848,21 +856,6 @@ class V8_EXPORT Object : public Value {
   V8_WARN_UNUSED_RESULT MaybeLocal<Value> CallAsConstructor(
       Local<Context> context, int argc, Local<Value> argv[]);
 
-  /**
-   * 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();
-  }
-
   /**
    * If this object is a Set, Map, WeakSet or WeakMap, this returns a
    * representation of the elements of this object as an array.
@@ -909,8 +902,10 @@ class V8_EXPORT Object : public Value {
   Object();
   static void CheckCast(Value* obj);
   Local<Data> SlowGetInternalField(int index);
-  void* SlowGetAlignedPointerFromInternalField(int index);
-  void* SlowGetAlignedPointerFromInternalField(v8::Isolate* isolate, int index);
+  void* SlowGetAlignedPointerFromInternalField(int index,
+                                               EmbedderDataTypeTag tag);
+  void* SlowGetAlignedPointerFromInternalField(v8::Isolate* isolate, int index,
+                                               EmbedderDataTypeTag tag);
 };
 
 // --- Implementation ---
@@ -929,7 +924,7 @@ Local<Data> Object::GetInternalField(int index) {
     A value = I::ReadRawField<A>(obj, offset);
 #ifdef V8_COMPRESS_POINTERS
     // We read the full pointer value and then decompress it in order to avoid
-    // dealing with potential endiannes issues.
+    // dealing with potential endianness issues.
     value = I::DecompressTaggedField(obj, static_cast<uint32_t>(value));
 #endif
 
@@ -941,7 +936,8 @@ Local<Data> Object::GetInternalField(int index) {
 }
 
 void* Object::GetAlignedPointerFromInternalField(v8::Isolate* isolate,
-                                                 int index) {
+                                                 int index,
+                                                 EmbedderDataTypeTag tag) {
 #if !defined(V8_ENABLE_CHECKS)
   using A = internal::Address;
   using I = internal::Internals;
@@ -953,17 +949,16 @@ void* Object::GetAlignedPointerFromInternalField(v8::Isolate* isolate,
     int offset = I::kJSAPIObjectWithEmbedderSlotsHeaderSize +
                  (I::kEmbedderDataSlotSize * index) +
                  I::kEmbedderDataSlotExternalPointerOffset;
-    A value =
-        I::ReadExternalPointerField<{internal::kFirstEmbedderDataTag,
-                                     internal::kLastEmbedderDataTag}>(
-            isolate, obj, offset);
+    A value = I::ReadExternalPointerField(isolate, obj, offset,
+                                          ToExternalPointerTag(tag));
     return reinterpret_cast<void*>(value);
   }
 #endif
-  return SlowGetAlignedPointerFromInternalField(isolate, index);
+  return SlowGetAlignedPointerFromInternalField(isolate, index, tag);
 }
 
-void* Object::GetAlignedPointerFromInternalField(int index) {
+void* Object::GetAlignedPointerFromInternalField(int index,
+                                                 EmbedderDataTypeTag tag) {
 #if !defined(V8_ENABLE_CHECKS)
   using A = internal::Address;
   using I = internal::Internals;
@@ -976,14 +971,12 @@ void* Object::GetAlignedPointerFromInternalField(int index) {
                  (I::kEmbedderDataSlotSize * index) +
                  I::kEmbedderDataSlotExternalPointerOffset;
     Isolate* isolate = I::GetCurrentIsolateForSandbox();
-    A value =
-        I::ReadExternalPointerField<{internal::kFirstEmbedderDataTag,
-                                     internal::kLastEmbedderDataTag}>(
-            isolate, obj, offset);
+    A value = I::ReadExternalPointerField(isolate, obj, offset,
+                                          ToExternalPointerTag(tag));
     return reinterpret_cast<void*>(value);
   }
 #endif
-  return SlowGetAlignedPointerFromInternalField(index);
+  return SlowGetAlignedPointerFromInternalField(index, tag);
 }
 
 // static

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

@@ -485,20 +485,13 @@ V8_INLINE void PersistentBase<T>::SetWeak(
     P* parameter, typename WeakCallbackInfo<P>::Callback callback,
     WeakCallbackType type) {
   using Callback = WeakCallbackInfo<void>::Callback;
-#if (__GNUC__ >= 8) && !defined(__clang__)
+#if (__GNUC__ >= 8) || defined(__clang__)
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wcast-function-type"
-#endif
-#if __clang__
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wcast-function-type"
 #endif
   api_internal::MakeWeak(this->slot(), parameter,
                          reinterpret_cast<Callback>(callback), type);
-#if __clang__
-#pragma clang diagnostic pop
-#endif
-#if (__GNUC__ >= 8) && !defined(__clang__)
+#if (__GNUC__ >= 8) || defined(__clang__)
 #pragma GCC diagnostic pop
 #endif
 }