libv8-node 21.7.2.0-x86_64-linux → 22.5.1.0-x86_64-linux

data/vendor/v8/include/v8-local-handle.h

@@ -8,8 +8,10 @@
 #include <stddef.h>
 
 #include <type_traits>
+#include <vector>
 
 #include "v8-handle-base.h"  // NOLINT(build/include_directory)
+#include "v8-internal.h"     // NOLINT(build/include_directory)
 
 namespace v8 {
 
@@ -17,6 +19,8 @@ template <class T>
 class LocalBase;
 template <class T>
 class Local;
+template <class T>
+class LocalVector;
 template <class F>
 class MaybeLocal;
 
@@ -58,6 +62,7 @@ class ReturnValue;
 class String;
 template <class F>
 class Traced;
+class TypecheckWitness;
 class Utils;
 
 namespace debug {
@@ -67,6 +72,8 @@ class ConsoleCallArguments;
 namespace internal {
 template <typename T>
 class CustomArguments;
+template <typename T>
+class LocalUnchecked;
 class SamplingHeapProfiler;
 }  // namespace internal
 
@@ -129,6 +136,9 @@ class V8_EXPORT V8_NODISCARD HandleScope {
   internal::Isolate* i_isolate_;
   internal::Address* prev_next_;
   internal::Address* prev_limit_;
+#ifdef V8_ENABLE_CHECKS
+  int scope_level_ = 0;
+#endif
 
   // LocalBase<T>::New uses CreateHandle with an Isolate* parameter.
   template <typename T>
@@ -149,7 +159,7 @@ class V8_EXPORT V8_NODISCARD HandleScope {
 #ifdef V8_ENABLE_DIRECT_LOCAL
 
 template <typename T>
-class LocalBase : public DirectHandleBase {
+class LocalBase : public api_internal::DirectHandleBase {
  protected:
   template <class F>
   friend class Local;
@@ -178,7 +188,7 @@ class LocalBase : public DirectHandleBase {
 #else  // !V8_ENABLE_DIRECT_LOCAL
 
 template <typename T>
-class LocalBase : public IndirectHandleBase {
+class LocalBase : public api_internal::IndirectHandleBase {
  protected:
   template <class F>
   friend class Local;
@@ -239,7 +249,13 @@ class LocalBase : public IndirectHandleBase {
  * to these values as to their handles.
  */
 template <class T>
-class Local : public LocalBase<T> {
+class V8_TRIVIAL_ABI Local : public LocalBase<T>,
+#ifdef V8_ENABLE_LOCAL_OFF_STACK_CHECK
+                             public api_internal::StackAllocated<true>
+#else
+                             public api_internal::StackAllocated<false>
+#endif
+{
  public:
   V8_INLINE Local() = default;
 
@@ -320,17 +336,17 @@ class Local : public LocalBase<T> {
    * the original handle is destroyed/disposed.
    */
   V8_INLINE static Local<T> New(Isolate* isolate, Local<T> that) {
-    return New(isolate, that.template value<T>());
+    return New(isolate, that.template value<T, true>());
   }
 
   V8_INLINE static Local<T> New(Isolate* isolate,
                                 const PersistentBase<T>& that) {
-    return New(isolate, that.template value<T>());
+    return New(isolate, that.template value<T, true>());
   }
 
   V8_INLINE static Local<T> New(Isolate* isolate,
                                 const BasicTracedReference<T>& that) {
-    return New(isolate, that.template value<T>());
+    return New(isolate, that.template value<T, true>());
   }
 
  private:
@@ -363,6 +379,7 @@ class Local : public LocalBase<T> {
   friend Local<Boolean> False(Isolate* isolate);
   friend class HandleScope;
   friend class EscapableHandleScope;
+  friend class InternalEscapableScope;
   template <class F1, class F2, class F3>
   friend class PersistentValueMapBase;
   template <class F1, class F2>
@@ -374,6 +391,12 @@ class Local : public LocalBase<T> {
   friend class internal::SamplingHeapProfiler;
   friend class internal::HandleHelper;
   friend class debug::ConsoleCallArguments;
+  friend class internal::LocalUnchecked<T>;
+
+  explicit Local(no_checking_tag do_not_check)
+      : LocalBase<T>(), StackAllocated(do_not_check) {}
+  explicit Local(const Local<T>& other, no_checking_tag do_not_check)
+      : LocalBase<T>(other), StackAllocated(do_not_check) {}
 
   V8_INLINE explicit Local<T>(const LocalBase<T>& other)
       : LocalBase<T>(other) {}
@@ -383,6 +406,8 @@ class Local : public LocalBase<T> {
   }
 
 #ifdef V8_ENABLE_DIRECT_LOCAL
+  friend class TypecheckWitness;
+
   V8_INLINE static Local<T> FromAddress(internal::Address ptr) {
     return Local<T>(LocalBase<T>(ptr));
   }
@@ -403,6 +428,174 @@ class Local : public LocalBase<T> {
   }
 };
 
+namespace internal {
+// A local variant that is suitable for off-stack allocation.
+// Used internally by LocalVector<T>. Not to be used directly!
+template <typename T>
+class V8_TRIVIAL_ABI LocalUnchecked : public Local<T> {
+ public:
+  LocalUnchecked() : Local<T>(Local<T>::do_not_check) {}
+
+#if defined(V8_ENABLE_LOCAL_OFF_STACK_CHECK) && V8_HAS_ATTRIBUTE_TRIVIAL_ABI
+  // In this case, the check is also enforced in the copy constructor and we
+  // need to suppress it.
+  LocalUnchecked(const LocalUnchecked& other)
+      : Local<T>(other, Local<T>::do_not_check) {}
+  LocalUnchecked& operator=(const LocalUnchecked&) = default;
+#endif
+
+  // Implicit conversion from Local.
+  LocalUnchecked(const Local<T>& other)  // NOLINT(runtime/explicit)
+      : Local<T>(other, Local<T>::do_not_check) {}
+};
+
+#ifdef V8_ENABLE_DIRECT_LOCAL
+// Off-stack allocated direct locals must be registered as strong roots.
+// For off-stack indirect locals, this is not necessary.
+
+template <typename T>
+class StrongRootAllocator<LocalUnchecked<T>> : public StrongRootAllocatorBase {
+ public:
+  using value_type = LocalUnchecked<T>;
+  static_assert(std::is_standard_layout_v<value_type>);
+  static_assert(sizeof(value_type) == sizeof(Address));
+
+  explicit StrongRootAllocator(Heap* heap) : StrongRootAllocatorBase(heap) {}
+  explicit StrongRootAllocator(v8::Isolate* isolate)
+      : StrongRootAllocatorBase(isolate) {}
+  template <typename U>
+  StrongRootAllocator(const StrongRootAllocator<U>& other) noexcept
+      : StrongRootAllocatorBase(other) {}
+
+  value_type* allocate(size_t n) {
+    return reinterpret_cast<value_type*>(allocate_impl(n));
+  }
+  void deallocate(value_type* p, size_t n) noexcept {
+    return deallocate_impl(reinterpret_cast<Address*>(p), n);
+  }
+};
+#endif  // V8_ENABLE_DIRECT_LOCAL
+}  // namespace internal
+
+template <typename T>
+class LocalVector {
+ private:
+  using element_type = internal::LocalUnchecked<T>;
+
+#ifdef V8_ENABLE_DIRECT_LOCAL
+  using allocator_type = internal::StrongRootAllocator<element_type>;
+
+  static allocator_type make_allocator(Isolate* isolate) noexcept {
+    return allocator_type(isolate);
+  }
+#else
+  using allocator_type = std::allocator<element_type>;
+
+  static allocator_type make_allocator(Isolate* isolate) noexcept {
+    return allocator_type();
+  }
+#endif  // V8_ENABLE_DIRECT_LOCAL
+
+  using vector_type = std::vector<element_type, allocator_type>;
+
+ public:
+  using value_type = Local<T>;
+  using reference = value_type&;
+  using const_reference = const value_type&;
+  using size_type = size_t;
+  using difference_type = ptrdiff_t;
+  using iterator =
+      internal::WrappedIterator<typename vector_type::iterator, Local<T>>;
+  using const_iterator =
+      internal::WrappedIterator<typename vector_type::const_iterator,
+                                const Local<T>>;
+
+  explicit LocalVector(Isolate* isolate) : backing_(make_allocator(isolate)) {}
+  LocalVector(Isolate* isolate, size_t n)
+      : backing_(n, make_allocator(isolate)) {}
+  explicit LocalVector(Isolate* isolate, std::initializer_list<Local<T>> init)
+      : backing_(make_allocator(isolate)) {
+    if (init.size() == 0) return;
+    backing_.reserve(init.size());
+    backing_.insert(backing_.end(), init.begin(), init.end());
+  }
+
+  iterator begin() noexcept { return iterator(backing_.begin()); }
+  const_iterator begin() const noexcept {
+    return const_iterator(backing_.begin());
+  }
+  iterator end() noexcept { return iterator(backing_.end()); }
+  const_iterator end() const noexcept { return const_iterator(backing_.end()); }
+
+  size_t size() const noexcept { return backing_.size(); }
+  bool empty() const noexcept { return backing_.empty(); }
+  void reserve(size_t n) { backing_.reserve(n); }
+  void shrink_to_fit() { backing_.shrink_to_fit(); }
+
+  Local<T>& operator[](size_t n) { return backing_[n]; }
+  const Local<T>& operator[](size_t n) const { return backing_[n]; }
+
+  Local<T>& at(size_t n) { return backing_.at(n); }
+  const Local<T>& at(size_t n) const { return backing_.at(n); }
+
+  Local<T>& front() { return backing_.front(); }
+  const Local<T>& front() const { return backing_.front(); }
+  Local<T>& back() { return backing_.back(); }
+  const Local<T>& back() const { return backing_.back(); }
+
+  Local<T>* data() noexcept { return backing_.data(); }
+  const Local<T>* data() const noexcept { return backing_.data(); }
+
+  iterator insert(const_iterator pos, const Local<T>& value) {
+    return iterator(backing_.insert(pos.base(), value));
+  }
+
+  template <typename InputIt>
+  iterator insert(const_iterator pos, InputIt first, InputIt last) {
+    return iterator(backing_.insert(pos.base(), first, last));
+  }
+
+  iterator insert(const_iterator pos, std::initializer_list<Local<T>> init) {
+    return iterator(backing_.insert(pos.base(), init.begin(), init.end()));
+  }
+
+  LocalVector<T>& operator=(std::initializer_list<Local<T>> init) {
+    backing_.clear();
+    backing_.insert(backing_.end(), init.begin(), init.end());
+    return *this;
+  }
+
+  void push_back(const Local<T>& x) { backing_.push_back(x); }
+  void pop_back() { backing_.pop_back(); }
+  void emplace_back(const Local<T>& x) { backing_.emplace_back(x); }
+
+  void clear() noexcept { backing_.clear(); }
+  void resize(size_t n) { backing_.resize(n); }
+  void swap(LocalVector<T>& other) { backing_.swap(other.backing_); }
+
+  friend bool operator==(const LocalVector<T>& x, const LocalVector<T>& y) {
+    return x.backing_ == y.backing_;
+  }
+  friend bool operator!=(const LocalVector<T>& x, const LocalVector<T>& y) {
+    return x.backing_ != y.backing_;
+  }
+  friend bool operator<(const LocalVector<T>& x, const LocalVector<T>& y) {
+    return x.backing_ < y.backing_;
+  }
+  friend bool operator>(const LocalVector<T>& x, const LocalVector<T>& y) {
+    return x.backing_ > y.backing_;
+  }
+  friend bool operator<=(const LocalVector<T>& x, const LocalVector<T>& y) {
+    return x.backing_ <= y.backing_;
+  }
+  friend bool operator>=(const LocalVector<T>& x, const LocalVector<T>& y) {
+    return x.backing_ >= y.backing_;
+  }
+
+ private:
+  vector_type backing_;
+};
+
 #if !defined(V8_IMMINENT_DEPRECATION_WARNINGS)
 // Handle is an alias for Local for historical reasons.
 template <class T>
@@ -456,29 +649,79 @@ class MaybeLocal {
     return IsEmpty() ? default_value : Local<S>(local_);
   }
 
+  /**
+   * Cast a handle to a subclass, e.g. MaybeLocal<Value> to MaybeLocal<Object>.
+   * This is only valid if the handle actually refers to a value of the target
+   * type.
+   */
+  template <class S>
+  V8_INLINE static MaybeLocal<T> Cast(MaybeLocal<S> that) {
+#ifdef V8_ENABLE_CHECKS
+    // If we're going to perform the type check then we have to check
+    // that the handle isn't empty before doing the checked cast.
+    if (that.IsEmpty()) return MaybeLocal<T>();
+    T::Cast(that.local_.template value<S>());
+#endif
+    return MaybeLocal<T>(that.local_);
+  }
+
+  /**
+   * Calling this is equivalent to MaybeLocal<S>::Cast().
+   * In particular, this is only valid if the handle actually refers to a value
+   * of the target type.
+   */
+  template <class S>
+  V8_INLINE MaybeLocal<S> As() const {
+    return MaybeLocal<S>::Cast(*this);
+  }
+
  private:
   Local<T> local_;
+
+  template <typename S>
+  friend class MaybeLocal;
 };
 
 /**
  * A HandleScope which first allocates a handle in the current scope
  * which will be later filled with the escape value.
  */
-class V8_EXPORT V8_NODISCARD EscapableHandleScope : public HandleScope {
+class V8_EXPORT V8_NODISCARD EscapableHandleScopeBase : public HandleScope {
  public:
-  explicit EscapableHandleScope(Isolate* isolate);
-  V8_INLINE ~EscapableHandleScope() = default;
+  explicit EscapableHandleScopeBase(Isolate* isolate);
+  V8_INLINE ~EscapableHandleScopeBase() = default;
+
+  EscapableHandleScopeBase(const EscapableHandleScopeBase&) = delete;
+  void operator=(const EscapableHandleScopeBase&) = delete;
+  void* operator new(size_t size) = delete;
+  void* operator new[](size_t size) = delete;
+  void operator delete(void*, size_t) = delete;
+  void operator delete[](void*, size_t) = delete;
 
+ protected:
   /**
    * Pushes the value into the previous scope and returns a handle to it.
    * Cannot be called twice.
    */
+  internal::Address* EscapeSlot(internal::Address* escape_value);
+
+ private:
+  internal::Address* escape_slot_;
+};
+
+class V8_EXPORT V8_NODISCARD EscapableHandleScope
+    : public EscapableHandleScopeBase {
+ public:
+  explicit EscapableHandleScope(Isolate* isolate)
+      : EscapableHandleScopeBase(isolate) {}
+  V8_INLINE ~EscapableHandleScope() = default;
   template <class T>
   V8_INLINE Local<T> Escape(Local<T> value) {
 #ifdef V8_ENABLE_DIRECT_LOCAL
     return value;
 #else
-    return Local<T>::FromSlot(Escape(value.slot()));
+    if (value.IsEmpty()) return value;
+    return Local<T>::FromSlot(EscapeSlot(value.slot()));
 #endif
   }
 
@@ -486,20 +729,6 @@ class V8_EXPORT V8_NODISCARD EscapableHandleScope : public HandleScope {
   V8_INLINE MaybeLocal<T> EscapeMaybe(MaybeLocal<T> value) {
     return Escape(value.FromMaybe(Local<T>()));
   }
-
-  EscapableHandleScope(const EscapableHandleScope&) = delete;
-  void operator=(const EscapableHandleScope&) = delete;
-
- private:
-  // 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);
-  void* operator new[](size_t size);
-  void operator delete(void*, size_t);
-  void operator delete[](void*, size_t);
-
-  internal::Address* Escape(internal::Address* escape_value);
-  internal::Address* escape_slot_;
 };
 
 /**
@@ -514,15 +743,12 @@ class V8_EXPORT V8_NODISCARD SealHandleScope {
 
   SealHandleScope(const SealHandleScope&) = delete;
   void operator=(const SealHandleScope&) = delete;
+  void* operator new(size_t size) = delete;
+  void* operator new[](size_t size) = delete;
+  void operator delete(void*, size_t) = delete;
+  void operator delete[](void*, size_t) = delete;
 
  private:
-  // 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);
-  void* operator new[](size_t size);
-  void operator delete(void*, size_t);
-  void operator delete[](void*, size_t);
-
   internal::Isolate* const i_isolate_;
   internal::Address* prev_limit_;
   int prev_sealed_level_;

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 {