libv8-node 20.12.1.0-arm64-darwin → 22.5.1.0-arm64-darwin

data/vendor/v8/include/v8-memory-span.h

@@ -7,12 +7,16 @@
 
 #include <stddef.h>
 
+#include <array>
+#include <iterator>
+#include <type_traits>
+
 #include "v8config.h"  // NOLINT(build/include_directory)
 
 namespace v8 {
 
 /**
- * Points to an unowned continous buffer holding a known number of elements.
+ * Points to an unowned contiguous buffer holding a known number of elements.
  *
  * This is similar to std::span (under consideration for C++20), but does not
  * require advanced C++ support. In the (far) future, this may be replaced with
@@ -23,21 +27,172 @@ namespace v8 {
  */
 template <typename T>
 class V8_EXPORT MemorySpan {
+ private:
+  /** Some C++ machinery, brought from the future. */
+  template <typename From, typename To>
+  using is_array_convertible = std::is_convertible<From (*)[], To (*)[]>;
+  template <typename From, typename To>
+  static constexpr bool is_array_convertible_v =
+      is_array_convertible<From, To>::value;
+
+  template <typename It>
+  using iter_reference_t = decltype(*std::declval<It&>());
+
+  template <typename It, typename = void>
+  struct is_compatible_iterator : std::false_type {};
+  template <typename It>
+  struct is_compatible_iterator<
+      It,
+      std::void_t<
+          std::is_base_of<std::random_access_iterator_tag,
+                          typename std::iterator_traits<It>::iterator_category>,
+          is_array_convertible<std::remove_reference_t<iter_reference_t<It>>,
+                               T>>> : std::true_type {};
+  template <typename It>
+  static constexpr bool is_compatible_iterator_v =
+      is_compatible_iterator<It>::value;
+
+  template <typename U>
+  static constexpr U* to_address(U* p) noexcept {
+    return p;
+  }
+
+  template <typename It,
+            typename = std::void_t<decltype(std::declval<It&>().operator->())>>
+  static constexpr auto to_address(It it) noexcept {
+    return it.operator->();
+  }
+
  public:
   /** The default constructor creates an empty span. */
   constexpr MemorySpan() = default;
 
-  constexpr MemorySpan(T* data, size_t size) : data_(data), size_(size) {}
+  /** Constructor from nullptr and count, for backwards compatibility.
+   * This is not compatible with C++20 std::span.
+   */
+  constexpr MemorySpan(std::nullptr_t, size_t) {}
+
+  /** Constructor from "iterator" and count. */
+  template <typename Iterator,
+            std::enable_if_t<is_compatible_iterator_v<Iterator>, bool> = true>
+  constexpr MemorySpan(Iterator first,
+                       size_t count)  // NOLINT(runtime/explicit)
+      : data_(to_address(first)), size_(count) {}
+
+  /** Constructor from two "iterators". */
+  template <typename Iterator,
+            std::enable_if_t<is_compatible_iterator_v<Iterator> &&
+                                 !std::is_convertible_v<Iterator, size_t>,
+                             bool> = true>
+  constexpr MemorySpan(Iterator first,
+                       Iterator last)  // NOLINT(runtime/explicit)
+      : data_(to_address(first)), size_(last - first) {}
+
+  /** Implicit conversion from C-style array. */
+  template <size_t N>
+  constexpr MemorySpan(T (&a)[N]) noexcept  // NOLINT(runtime/explicit)
+      : data_(a), size_(N) {}
+
+  /** Implicit conversion from std::array. */
+  template <typename U, size_t N,
+            std::enable_if_t<is_array_convertible_v<U, T>, bool> = true>
+  constexpr MemorySpan(
+      std::array<U, N>& a) noexcept  // NOLINT(runtime/explicit)
+      : data_(a.data()), size_{N} {}
+
+  /** Implicit conversion from const std::array. */
+  template <typename U, size_t N,
+            std::enable_if_t<is_array_convertible_v<const U, T>, bool> = true>
+  constexpr MemorySpan(
+      const std::array<U, N>& a) noexcept  // NOLINT(runtime/explicit)
+      : data_(a.data()), size_{N} {}
 
   /** Returns a pointer to the beginning of the buffer. */
   constexpr T* data() const { return data_; }
   /** Returns the number of elements that the buffer holds. */
   constexpr size_t size() const { return size_; }
 
+  constexpr T& operator[](size_t i) const { return data_[i]; }
+
+  /** Returns true if the buffer is empty. */
+  constexpr bool empty() const { return size() == 0; }
+
+  class Iterator {
+   public:
+    using iterator_category = std::forward_iterator_tag;
+    using value_type = T;
+    using difference_type = std::ptrdiff_t;
+    using pointer = value_type*;
+    using reference = value_type&;
+
+    T& operator*() const { return *ptr_; }
+    T* operator->() const { return ptr_; }
+
+    bool operator==(Iterator other) const { return ptr_ == other.ptr_; }
+    bool operator!=(Iterator other) const { return !(*this == other); }
+
+    Iterator& operator++() {
+      ++ptr_;
+      return *this;
+    }
+
+    Iterator operator++(int) {
+      Iterator temp(*this);
+      ++(*this);
+      return temp;
+    }
+
+   private:
+    friend class MemorySpan<T>;
+
+    explicit Iterator(T* ptr) : ptr_(ptr) {}
+
+    T* ptr_ = nullptr;
+  };
+
+  Iterator begin() const { return Iterator(data_); }
+  Iterator end() const { return Iterator(data_ + size_); }
+
  private:
   T* data_ = nullptr;
   size_t size_ = 0;
 };
 
+/**
+ * Helper function template to create an array of fixed length, initialized by
+ * the provided initializer list, without explicitly specifying the array size,
+ * e.g.
+ *
+ *   auto arr = v8::to_array<Local<String>>({v8_str("one"), v8_str("two")});
+ *
+ * In the future, this may be replaced with or aliased to std::to_array (under
+ * consideration for C++20).
+ */
+
+namespace detail {
+template <class T, std::size_t N, std::size_t... I>
+constexpr std::array<std::remove_cv_t<T>, N> to_array_lvalue_impl(
+    T (&a)[N], std::index_sequence<I...>) {
+  return {{a[I]...}};
+}
+
+template <class T, std::size_t N, std::size_t... I>
+constexpr std::array<std::remove_cv_t<T>, N> to_array_rvalue_impl(
+    T (&&a)[N], std::index_sequence<I...>) {
+  return {{std::move(a[I])...}};
+}
+}  // namespace detail
+
+template <class T, std::size_t N>
+constexpr std::array<std::remove_cv_t<T>, N> to_array(T (&a)[N]) {
+  return detail::to_array_lvalue_impl(a, std::make_index_sequence<N>{});
+}
+
+template <class T, std::size_t N>
+constexpr std::array<std::remove_cv_t<T>, N> to_array(T (&&a)[N]) {
+  return detail::to_array_rvalue_impl(std::move(a),
+                                      std::make_index_sequence<N>{});
+}
+
 }  // namespace v8
 #endif  // INCLUDE_V8_MEMORY_SPAN_H_

data/vendor/v8/include/v8-message.h

@@ -61,6 +61,7 @@ class ScriptOriginOptions {
  */
 class V8_EXPORT ScriptOrigin {
  public:
+  V8_DEPRECATE_SOON("Use constructor without the isolate.")
   V8_INLINE ScriptOrigin(Isolate* isolate, Local<Value> resource_name,
                          int resource_line_offset = 0,
                          int resource_column_offset = 0,
@@ -70,8 +71,27 @@ class V8_EXPORT ScriptOrigin {
                          bool resource_is_opaque = false, bool is_wasm = false,
                          bool is_module = false,
                          Local<Data> host_defined_options = Local<Data>())
-      : v8_isolate_(isolate),
-        resource_name_(resource_name),
+      : resource_name_(resource_name),
+        resource_line_offset_(resource_line_offset),
+        resource_column_offset_(resource_column_offset),
+        options_(resource_is_shared_cross_origin, resource_is_opaque, is_wasm,
+                 is_module),
+        script_id_(script_id),
+        source_map_url_(source_map_url),
+        host_defined_options_(host_defined_options) {
+    VerifyHostDefinedOptions();
+  }
+
+  V8_INLINE ScriptOrigin(Local<Value> resource_name,
+                         int resource_line_offset = 0,
+                         int resource_column_offset = 0,
+                         bool resource_is_shared_cross_origin = false,
+                         int script_id = -1,
+                         Local<Value> source_map_url = Local<Value>(),
+                         bool resource_is_opaque = false, bool is_wasm = false,
+                         bool is_module = false,
+                         Local<Data> host_defined_options = Local<Data>())
+      : resource_name_(resource_name),
         resource_line_offset_(resource_line_offset),
         resource_column_offset_(resource_column_offset),
         options_(resource_is_shared_cross_origin, resource_is_opaque, is_wasm,
@@ -92,7 +112,6 @@ class V8_EXPORT ScriptOrigin {
 
  private:
   void VerifyHostDefinedOptions() const;
-  Isolate* v8_isolate_;
   Local<Value> resource_name_;
   int resource_line_offset_;
   int resource_column_offset_;

data/vendor/v8/include/v8-metrics.h

@@ -55,6 +55,7 @@ struct GarbageCollectionFullCycle {
   double efficiency_cpp_in_bytes_per_us = -1.0;
   double main_thread_efficiency_in_bytes_per_us = -1.0;
   double main_thread_efficiency_cpp_in_bytes_per_us = -1.0;
+  int64_t incremental_marking_start_stop_wall_clock_duration_in_us = -1;
 };
 
 struct GarbageCollectionFullMainThreadIncrementalMark {

data/vendor/v8/include/v8-object.h

@@ -20,8 +20,6 @@ class Function;
 class FunctionTemplate;
 template <typename T>
 class PropertyCallbackInfo;
-class Module;
-class UnboundScript;
 
 /**
  * A private symbol
@@ -167,17 +165,13 @@ using AccessorNameSetterCallback =
 /**
  * Access control specifications.
  *
- * Some accessors should be accessible across contexts.  These
+ * 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.
  *
- * TODO(dcarney): Remove PROHIBITS_OVERWRITING as it is now unused.
  */
 enum AccessControl {
   DEFAULT = 0,
-  ALL_CAN_READ = 1,
-  ALL_CAN_WRITE = 1 << 1,
-  PROHIBITS_OVERWRITING = 1 << 2
 };
 
 /**
@@ -249,13 +243,16 @@ class V8_EXPORT Object : public Value {
   V8_WARN_UNUSED_RESULT Maybe<bool> Set(Local<Context> context, uint32_t index,
                                         Local<Value> value);
 
-  // Implements CreateDataProperty (ECMA-262, 7.3.4).
-  //
-  // Defines a configurable, writable, enumerable property with the given value
-  // on the object unless the property already exists and is not configurable
-  // or the object is not extensible.
-  //
-  // Returns true on success.
+  /**
+   * Implements CreateDataProperty(O, P, V), see
+   * https://tc39.es/ecma262/#sec-createdataproperty.
+   *
+   * Defines a configurable, writable, enumerable property with the given value
+   * on the object unless the property already exists and is not configurable
+   * or the object is not extensible.
+   *
+   * Returns true on success.
+   */
   V8_WARN_UNUSED_RESULT Maybe<bool> CreateDataProperty(Local<Context> context,
                                                        Local<Name> key,
                                                        Local<Value> value);
@@ -263,29 +260,35 @@ class V8_EXPORT Object : public Value {
                                                        uint32_t index,
                                                        Local<Value> value);
 
-  // Implements DefineOwnProperty.
-  //
-  // In general, CreateDataProperty will be faster, however, does not allow
-  // for specifying attributes.
-  //
-  // Returns true on success.
+  /**
+   * Implements [[DefineOwnProperty]] for data property case, see
+   * https://tc39.es/ecma262/#table-essential-internal-methods.
+   *
+   * In general, CreateDataProperty will be faster, however, does not allow
+   * for specifying attributes.
+   *
+   * Returns true on success.
+   */
   V8_WARN_UNUSED_RESULT Maybe<bool> DefineOwnProperty(
       Local<Context> context, Local<Name> key, Local<Value> value,
       PropertyAttribute attributes = None);
 
-  // Implements Object.DefineProperty(O, P, Attributes), see Ecma-262 19.1.2.4.
-  //
-  // The defineProperty function is used to add an own property or
-  // update the attributes of an existing own property of an object.
-  //
-  // Both data and accessor descriptors can be used.
-  //
-  // In general, CreateDataProperty is faster, however, does not allow
-  // for specifying attributes or an accessor descriptor.
-  //
-  // The PropertyDescriptor can change when redefining a property.
-  //
-  // Returns true on success.
+  /**
+   * Implements Object.defineProperty(O, P, Attributes), see
+   * https://tc39.es/ecma262/#sec-object.defineproperty.
+   *
+   * The defineProperty function is used to add an own property or
+   * update the attributes of an existing own property of an object.
+   *
+   * Both data and accessor descriptors can be used.
+   *
+   * In general, CreateDataProperty is faster, however, does not allow
+   * for specifying attributes or an accessor descriptor.
+   *
+   * The PropertyDescriptor can change when redefining a property.
+   *
+   * Returns true on success.
+   */
   V8_WARN_UNUSED_RESULT Maybe<bool> DefineProperty(
       Local<Context> context, Local<Name> key, PropertyDescriptor& descriptor);
 
@@ -304,14 +307,15 @@ class V8_EXPORT Object : public Value {
       Local<Context> context, Local<Value> key);
 
   /**
-   * Returns Object.getOwnPropertyDescriptor as per ES2016 section 19.1.2.6.
+   * Implements Object.getOwnPropertyDescriptor(O, P), see
+   * https://tc39.es/ecma262/#sec-object.getownpropertydescriptor.
    */
   V8_WARN_UNUSED_RESULT MaybeLocal<Value> GetOwnPropertyDescriptor(
       Local<Context> context, Local<Name> key);
 
   /**
-   * Object::Has() calls the abstract operation HasProperty(O, P) described
-   * in ECMA-262, 7.3.10. Has() returns
+   * Object::Has() calls the abstract operation HasProperty(O, P), see
+   * https://tc39.es/ecma262/#sec-hasproperty. Has() returns
    * true, if the object has the property, either own or on the prototype chain.
    * Interceptors, i.e., PropertyQueryCallbacks, are called if present.
    *
@@ -335,22 +339,20 @@ class V8_EXPORT Object : public Value {
   V8_WARN_UNUSED_RESULT Maybe<bool> Delete(Local<Context> context,
                                            uint32_t index);
 
-  /**
-   * Note: SideEffectType affects the getter only, not the setter.
-   */
+  V8_DEPRECATE_SOON("Use SetNativeDataProperty instead")
   V8_WARN_UNUSED_RESULT Maybe<bool> SetAccessor(
       Local<Context> context, Local<Name> name,
       AccessorNameGetterCallback getter,
       AccessorNameSetterCallback setter = nullptr,
       MaybeLocal<Value> data = MaybeLocal<Value>(),
-      AccessControl settings = DEFAULT, PropertyAttribute attribute = None,
+      AccessControl deprecated_settings = DEFAULT,
+      PropertyAttribute attribute = None,
       SideEffectType getter_side_effect_type = SideEffectType::kHasSideEffect,
       SideEffectType setter_side_effect_type = SideEffectType::kHasSideEffect);
 
   void SetAccessorProperty(Local<Name> name, Local<Function> getter,
                            Local<Function> setter = Local<Function>(),
-                           PropertyAttribute attribute = None,
-                           AccessControl settings = DEFAULT);
+                           PropertyAttribute attributes = None);
 
   /**
    * Sets a native data property like Template::SetNativeDataProperty, but
@@ -467,35 +469,29 @@ class V8_EXPORT Object : public Value {
   /** Same as above, but works for PersistentBase. */
   V8_INLINE static int InternalFieldCount(
       const PersistentBase<Object>& object) {
-    return object.val_->InternalFieldCount();
+    return object.template value<Object>()->InternalFieldCount();
   }
 
   /** Same as above, but works for BasicTracedReference. */
   V8_INLINE static int InternalFieldCount(
       const BasicTracedReference<Object>& object) {
-    return object->InternalFieldCount();
+    return object.template value<Object>()->InternalFieldCount();
   }
 
-  /** Gets the value from an internal field. */
-  V8_INLINE Local<Value> GetInternalField(int index);
-
-  /** Sets the value in an internal field. */
-  void SetInternalField(int index, Local<Value> value);
-
   /**
-   * Warning: These are Node.js-specific extentions used to avoid breaking
-   * changes in Node.js v20.x. They do not exist in V8 upstream and will
-   * not exist in Node.js v21.x. Node.js embedders and addon authors should
-   * not use them from v20.x.
-   */
-#ifndef NODE_WANT_INTERNALS
-  V8_DEPRECATED("This extention should only be used by Node.js core")
-#endif
-  void SetInternalFieldForNodeCore(int index, Local<Module> value);
-#ifndef NODE_WANT_INTERNALS
-  V8_DEPRECATED("This extention should only be used by Node.js core")
-#endif
-  void SetInternalFieldForNodeCore(int index, Local<UnboundScript> value);
+   * Gets the data from an internal field.
+   * To cast the return value into v8::Value subtypes, it needs to be
+   * casted to a v8::Value first. For example, to cast it into v8::External:
+   *
+   * object->GetInternalField(index).As<v8::Value>().As<v8::External>();
+   *
+   * The embedder should make sure that the internal field being retrieved
+   * using this method has already been set with SetInternalField() before.
+   **/
+  V8_INLINE Local<Data> GetInternalField(int index);
+
+  /** Sets the data in an internal field. */
+  void SetInternalField(int index, Local<Data> data);
 
   /**
    * Gets a 2-byte-aligned native pointer from an internal field. This field
@@ -503,17 +499,21 @@ class V8_EXPORT Object : public Value {
    * leads to undefined behavior.
    */
   V8_INLINE void* GetAlignedPointerFromInternalField(int index);
+  V8_INLINE void* GetAlignedPointerFromInternalField(v8::Isolate* isolate,
+                                                     int index);
 
   /** Same as above, but works for PersistentBase. */
   V8_INLINE static void* GetAlignedPointerFromInternalField(
       const PersistentBase<Object>& object, int index) {
-    return object.val_->GetAlignedPointerFromInternalField(index);
+    return object.template value<Object>()->GetAlignedPointerFromInternalField(
+        index);
   }
 
   /** Same as above, but works for TracedReference. */
   V8_INLINE static void* GetAlignedPointerFromInternalField(
       const BasicTracedReference<Object>& object, int index) {
-    return object->GetAlignedPointerFromInternalField(index);
+    return object.template value<Object>()->GetAlignedPointerFromInternalField(
+        index);
   }
 
   /**
@@ -621,7 +621,7 @@ class V8_EXPORT Object : public Value {
   /** Same as above, but works for Persistents */
   V8_INLINE static MaybeLocal<Context> GetCreationContext(
       const PersistentBase<Object>& object) {
-    return object.val_->GetCreationContext();
+    return object.template value<Object>()->GetCreationContext();
   }
 
   /**
@@ -687,6 +687,10 @@ class V8_EXPORT Object : public Value {
    */
   Isolate* GetIsolate();
 
+  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.
@@ -727,13 +731,14 @@ class V8_EXPORT Object : public Value {
  private:
   Object();
   static void CheckCast(Value* obj);
-  Local<Value> SlowGetInternalField(int index);
+  Local<Data> SlowGetInternalField(int index);
   void* SlowGetAlignedPointerFromInternalField(int index);
+  void* SlowGetAlignedPointerFromInternalField(v8::Isolate* isolate, int index);
 };
 
 // --- Implementation ---
 
-Local<Value> Object::GetInternalField(int index) {
+Local<Data> Object::GetInternalField(int index) {
 #ifndef V8_ENABLE_CHECKS
   using A = internal::Address;
   using I = internal::Internals;
@@ -750,19 +755,35 @@ Local<Value> Object::GetInternalField(int index) {
     value = I::DecompressTaggedField(obj, static_cast<uint32_t>(value));
 #endif
 
-#ifdef V8_ENABLE_CONSERVATIVE_STACK_SCANNING
-    return Local<Value>(reinterpret_cast<Value*>(value));
-#else
-    internal::Isolate* isolate =
-        internal::IsolateFromNeverReadOnlySpaceObject(obj);
-    A* result = HandleScope::CreateHandle(isolate, value);
-    return Local<Value>(reinterpret_cast<Value*>(result));
-#endif
+    auto isolate = reinterpret_cast<v8::Isolate*>(
+        internal::IsolateFromNeverReadOnlySpaceObject(obj));
+    return Local<Data>::New(isolate, value);
   }
 #endif
   return SlowGetInternalField(index);
 }
 
+void* Object::GetAlignedPointerFromInternalField(v8::Isolate* isolate,
+                                                 int index) {
+#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::kJSObjectHeaderSize + (I::kEmbedderDataSlotSize * index) +
+                 I::kEmbedderDataSlotExternalPointerOffset;
+    A value =
+        I::ReadExternalPointerField<internal::kEmbedderDataSlotPayloadTag>(
+            isolate, obj, offset);
+    return reinterpret_cast<void*>(value);
+  }
+#endif
+  return SlowGetAlignedPointerFromInternalField(isolate, index);
+}
+
 void* Object::GetAlignedPointerFromInternalField(int index) {
 #if !defined(V8_ENABLE_CHECKS)
   using A = internal::Address;
@@ -771,7 +792,7 @@ void* Object::GetAlignedPointerFromInternalField(int index) {
   // 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 (I::CanHaveInternalField(instance_type)) {
+  if (V8_LIKELY(I::CanHaveInternalField(instance_type))) {
     int offset = I::kJSObjectHeaderSize + (I::kEmbedderDataSlotSize * index) +
                  I::kEmbedderDataSlotExternalPointerOffset;
     Isolate* isolate = I::GetIsolateForSandbox(obj);