libv8-node 18.19.1.0-aarch64-linux → 19.9.0.0-aarch64-linux

data/vendor/v8/include/cppgc/platform.h

@@ -132,8 +132,8 @@ class V8_EXPORT Platform {
  *
  * Can be called multiple times when paired with `ShutdownProcess()`.
  *
- * \param page_allocator The allocator used for maintaining meta data. Must not
- *   change between multiple calls to InitializeProcess.
+ * \param page_allocator The allocator used for maintaining meta data. Must stay
+ *   always alive and not change between multiple calls to InitializeProcess.
  */
 V8_EXPORT void InitializeProcess(PageAllocator* page_allocator);
 

data/vendor/v8/include/cppgc/sentinel-pointer.h

@@ -13,9 +13,9 @@ namespace internal {
 // Special tag type used to denote some sentinel member. The semantics of the
 // sentinel is defined by the embedder.
 struct SentinelPointer {
+  static constexpr intptr_t kSentinelValue = 0b10;
   template <typename T>
   operator T*() const {
-    static constexpr intptr_t kSentinelValue = 1;
     return reinterpret_cast<T*>(kSentinelValue);
   }
   // Hidden friends.

data/vendor/v8/include/cppgc/trace-trait.h

@@ -16,6 +16,10 @@ class Visitor;
 
 namespace internal {
 
+class RootVisitor;
+
+using TraceRootCallback = void (*)(RootVisitor&, const void* object);
+
 // Implementation of the default TraceTrait handling GarbageCollected and
 // GarbageCollectedMixin.
 template <typename T,

data/vendor/v8/include/cppgc/type-traits.h

@@ -170,6 +170,15 @@ struct IsComplete {
       decltype(IsSizeOfKnown(std::declval<T*>()))::value;
 };
 
+template <typename T, typename U>
+constexpr bool IsDecayedSameV =
+    std::is_same_v<std::decay_t<T>, std::decay_t<U>>;
+
+template <typename B, typename D>
+constexpr bool IsStrictlyBaseOfV =
+    std::is_base_of_v<std::decay_t<B>, std::decay_t<D>> &&
+    !IsDecayedSameV<B, D>;
+
 }  // namespace internal
 
 /**

data/vendor/v8/include/cppgc/visitor.h

@@ -62,22 +62,6 @@ class V8_EXPORT Visitor {
 
   virtual ~Visitor() = default;
 
-  /**
-   * Trace method for raw pointers. Prefer the versions for managed pointers.
-   *
-   * \param member Reference retaining an object.
-   */
-  template <typename T>
-  void Trace(const T* t) {
-    static_assert(sizeof(T), "Pointee type must be fully defined.");
-    static_assert(internal::IsGarbageCollectedOrMixinType<T>::value,
-                  "T must be GarbageCollected or GarbageCollectedMixin type");
-    if (!t) {
-      return;
-    }
-    Visit(t, TraceTrait<T>::GetTraceDescriptor(t));
-  }
-
   /**
    * Trace method for Member.
    *
@@ -87,7 +71,7 @@ class V8_EXPORT Visitor {
   void Trace(const Member<T>& member) {
     const T* value = member.GetRawAtomic();
     CPPGC_DCHECK(value != kSentinelPointer);
-    Trace(value);
+    TraceImpl(value);
   }
 
   /**
@@ -231,23 +215,33 @@ class V8_EXPORT Visitor {
   void TraceStrongly(const WeakMember<T>& weak_member) {
     const T* value = weak_member.GetRawAtomic();
     CPPGC_DCHECK(value != kSentinelPointer);
-    Trace(value);
+    TraceImpl(value);
+  }
+
+  /**
+   * Trace method for retaining containers strongly.
+   *
+   * \param object reference to the container.
+   */
+  template <typename T>
+  void TraceStrongContainer(const T* object) {
+    TraceImpl(object);
   }
 
   /**
-   * Trace method for weak containers.
+   * Trace method for retaining containers weakly.
    *
-   * \param object reference of the weak container.
+   * \param object reference to the container.
    * \param callback to be invoked.
-   * \param data custom data that is passed to the callback.
+   * \param callback_data custom data that is passed to the callback.
    */
   template <typename T>
   void TraceWeakContainer(const T* object, WeakCallback callback,
-                          const void* data) {
+                          const void* callback_data) {
     if (!object) return;
     VisitWeakContainer(object, TraceTrait<T>::GetTraceDescriptor(object),
                        TraceTrait<T>::GetWeakTraceDescriptor(object), callback,
-                       data);
+                       callback_data);
   }
 
   /**
@@ -255,6 +249,7 @@ class V8_EXPORT Visitor {
    * compactable space. Such references maybe be arbitrarily moved by the GC.
    *
    * \param slot location of reference to object that might be moved by the GC.
+   * The slot must contain an uncompressed pointer.
    */
   template <typename T>
   void RegisterMovableReference(const T** slot) {
@@ -297,9 +292,6 @@ class V8_EXPORT Visitor {
   virtual void Visit(const void* self, TraceDescriptor) {}
   virtual void VisitWeak(const void* self, TraceDescriptor, WeakCallback,
                          const void* weak_member) {}
-  virtual void VisitRoot(const void*, TraceDescriptor, const SourceLocation&) {}
-  virtual void VisitWeakRoot(const void* self, TraceDescriptor, WeakCallback,
-                             const void* weak_root, const SourceLocation&) {}
   virtual void VisitEphemeron(const void* key, const void* value,
                               TraceDescriptor value_desc) {}
   virtual void VisitWeakContainer(const void* self, TraceDescriptor strong_desc,
@@ -320,44 +312,20 @@ class V8_EXPORT Visitor {
   static void HandleWeak(const LivenessBroker& info, const void* object) {
     const PointerType* weak = static_cast<const PointerType*>(object);
     auto* raw_ptr = weak->GetFromGC();
-    // Sentinel values are preserved for weak pointers.
-    if (raw_ptr == kSentinelPointer) return;
     if (!info.IsHeapObjectAlive(raw_ptr)) {
       weak->ClearFromGC();
     }
   }
 
-  template <typename Persistent,
-            std::enable_if_t<Persistent::IsStrongPersistent::value>* = nullptr>
-  void TraceRoot(const Persistent& p, const SourceLocation& loc) {
-    using PointeeType = typename Persistent::PointeeType;
-    static_assert(sizeof(PointeeType),
-                  "Persistent's pointee type must be fully defined");
-    static_assert(internal::IsGarbageCollectedOrMixinType<PointeeType>::value,
-                  "Persistent's pointee type must be GarbageCollected or "
-                  "GarbageCollectedMixin");
-    auto* ptr = p.GetFromGC();
-    if (!ptr) {
+  template <typename T>
+  void TraceImpl(const T* t) {
+    static_assert(sizeof(T), "Pointee type must be fully defined.");
+    static_assert(internal::IsGarbageCollectedOrMixinType<T>::value,
+                  "T must be GarbageCollected or GarbageCollectedMixin type");
+    if (!t) {
       return;
     }
-    VisitRoot(ptr, TraceTrait<PointeeType>::GetTraceDescriptor(ptr), loc);
-  }
-
-  template <
-      typename WeakPersistent,
-      std::enable_if_t<!WeakPersistent::IsStrongPersistent::value>* = nullptr>
-  void TraceRoot(const WeakPersistent& p, const SourceLocation& loc) {
-    using PointeeType = typename WeakPersistent::PointeeType;
-    static_assert(sizeof(PointeeType),
-                  "Persistent's pointee type must be fully defined");
-    static_assert(internal::IsGarbageCollectedOrMixinType<PointeeType>::value,
-                  "Persistent's pointee type must be GarbageCollected or "
-                  "GarbageCollectedMixin");
-    static_assert(!internal::IsAllocatedOnCompactableSpace<PointeeType>::value,
-                  "Weak references to compactable objects are not allowed");
-    auto* ptr = p.GetFromGC();
-    VisitWeakRoot(ptr, TraceTrait<PointeeType>::GetTraceDescriptor(ptr),
-                  &HandleWeak<WeakPersistent>, &p, loc);
+    Visit(t, TraceTrait<T>::GetTraceDescriptor(t));
   }
 
 #if V8_ENABLE_CHECKS
@@ -374,6 +342,70 @@ class V8_EXPORT Visitor {
   friend class internal::VisitorBase;
 };
 
+namespace internal {
+
+class V8_EXPORT RootVisitor {
+ public:
+  explicit RootVisitor(Visitor::Key) {}
+
+  virtual ~RootVisitor() = default;
+
+  template <typename AnyStrongPersistentType,
+            std::enable_if_t<
+                AnyStrongPersistentType::IsStrongPersistent::value>* = nullptr>
+  void Trace(const AnyStrongPersistentType& p) {
+    using PointeeType = typename AnyStrongPersistentType::PointeeType;
+    const void* object = Extract(p);
+    if (!object) {
+      return;
+    }
+    VisitRoot(object, TraceTrait<PointeeType>::GetTraceDescriptor(object),
+              p.Location());
+  }
+
+  template <typename AnyWeakPersistentType,
+            std::enable_if_t<
+                !AnyWeakPersistentType::IsStrongPersistent::value>* = nullptr>
+  void Trace(const AnyWeakPersistentType& p) {
+    using PointeeType = typename AnyWeakPersistentType::PointeeType;
+    static_assert(!internal::IsAllocatedOnCompactableSpace<PointeeType>::value,
+                  "Weak references to compactable objects are not allowed");
+    const void* object = Extract(p);
+    if (!object) {
+      return;
+    }
+    VisitWeakRoot(object, TraceTrait<PointeeType>::GetTraceDescriptor(object),
+                  &HandleWeak<AnyWeakPersistentType>, &p, p.Location());
+  }
+
+ protected:
+  virtual void VisitRoot(const void*, TraceDescriptor, const SourceLocation&) {}
+  virtual void VisitWeakRoot(const void* self, TraceDescriptor, WeakCallback,
+                             const void* weak_root, const SourceLocation&) {}
+
+ private:
+  template <typename AnyPersistentType>
+  static const void* Extract(AnyPersistentType& p) {
+    using PointeeType = typename AnyPersistentType::PointeeType;
+    static_assert(sizeof(PointeeType),
+                  "Persistent's pointee type must be fully defined");
+    static_assert(internal::IsGarbageCollectedOrMixinType<PointeeType>::value,
+                  "Persistent's pointee type must be GarbageCollected or "
+                  "GarbageCollectedMixin");
+    return p.GetFromGC();
+  }
+
+  template <typename PointerType>
+  static void HandleWeak(const LivenessBroker& info, const void* object) {
+    const PointerType* weak = static_cast<const PointerType*>(object);
+    auto* raw_ptr = weak->GetFromGC();
+    if (!info.IsHeapObjectAlive(raw_ptr)) {
+      weak->ClearFromGC();
+    }
+  }
+};
+
+}  // namespace internal
 }  // namespace cppgc
 
 #endif  // INCLUDE_CPPGC_VISITOR_H_

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

@@ -12,6 +12,7 @@
 #include "cppgc/common.h"
 #include "v8-data.h"          // NOLINT(build/include_directory)
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
+#include "v8-promise.h"       // NOLINT(build/include_directory)
 #include "v8config.h"         // NOLINT(build/include_directory)
 
 #if defined(V8_OS_WIN)
@@ -105,7 +106,7 @@ struct JitCodeEvent {
     size_t line_number_table_size;
   };
 
-  wasm_source_info_t* wasm_source_info;
+  wasm_source_info_t* wasm_source_info = nullptr;
 
   union {
     // Only valid for CODE_ADDED.
@@ -216,7 +217,13 @@ using AddHistogramSampleCallback = void (*)(void* histogram, int sample);
 
 using FatalErrorCallback = void (*)(const char* location, const char* message);
 
-using OOMErrorCallback = void (*)(const char* location, bool is_heap_oom);
+struct OOMDetails {
+  bool is_heap_oom = false;
+  const char* detail = nullptr;
+};
+
+using OOMErrorCallback = void (*)(const char* location,
+                                  const OOMDetails& details);
 
 using MessageCallback = void (*)(Local<Message> message, Local<Value> data);
 
@@ -231,8 +238,11 @@ enum class CrashKeyId {
   kIsolateAddress,
   kReadonlySpaceFirstPageAddress,
   kMapSpaceFirstPageAddress,
+  kCodeRangeBaseAddress,
   kCodeSpaceFirstPageAddress,
   kDumpType,
+  kSnapshotChecksumCalculated,
+  kSnapshotChecksumExpected,
 };
 
 using AddCrashKeyCallback = void (*)(CrashKeyId id, const std::string& value);
@@ -300,6 +310,13 @@ using ApiImplementationCallback = void (*)(const FunctionCallbackInfo<Value>&);
 // --- Callback for WebAssembly.compileStreaming ---
 using WasmStreamingCallback = void (*)(const FunctionCallbackInfo<Value>&);
 
+enum class WasmAsyncSuccess { kSuccess, kFail };
+
+// --- Callback called when async WebAssembly operations finish ---
+using WasmAsyncResolvePromiseCallback = void (*)(
+    Isolate* isolate, Local<Context> context, Local<Promise::Resolver> resolver,
+    Local<Value> result, WasmAsyncSuccess success);
+
 // --- Callback for loading source map file for Wasm profiling support
 using WasmLoadSourceMapCallback = Local<String> (*)(Isolate* isolate,
                                                     const char* name);
@@ -310,9 +327,6 @@ using WasmSimdEnabledCallback = bool (*)(Local<Context> context);
 // --- Callback for checking if WebAssembly exceptions are enabled ---
 using WasmExceptionsEnabledCallback = bool (*)(Local<Context> context);
 
-// --- Callback for checking if WebAssembly dynamic tiering is enabled ---
-using WasmDynamicTieringEnabledCallback = bool (*)(Local<Context> context);
-
 // --- Callback for checking if the SharedArrayBuffer constructor is enabled ---
 using SharedArrayBufferConstructorEnabledCallback =
     bool (*)(Local<Context> context);

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

@@ -244,6 +244,12 @@ class V8_EXPORT Context : public Data {
    */
   void SetErrorMessageForCodeGenerationFromStrings(Local<String> message);
 
+  /**
+   * Sets the error description for the exception that is thrown when
+   * wasm code generation is not allowed.
+   */
+  void SetErrorMessageForWasmCodeGeneration(Local<String> message);
+
   /**
    * Return data that was previously attached to the context snapshot via
    * SnapshotCreator, and removes the reference to it.
@@ -284,6 +290,7 @@ class V8_EXPORT Context : public Data {
                        Local<Function> after_hook,
                        Local<Function> resolve_hook);
 
+  bool HasTemplateLiteralObject(Local<Value> object);
   /**
    * Stack-allocated class which sets the execution context for all
    * operations executed within a local scope.
@@ -374,15 +381,13 @@ void* Context::GetAlignedPointerFromEmbedderData(int index) {
   A ctx = *reinterpret_cast<const A*>(this);
   A embedder_data =
       I::ReadTaggedPointerField(ctx, I::kNativeContextEmbedderDataOffset);
-  int value_offset =
-      I::kEmbedderDataArrayHeaderSize + (I::kEmbedderDataSlotSize * index);
-#ifdef V8_SANDBOXED_EXTERNAL_POINTERS
-  value_offset += I::kEmbedderDataSlotRawPayloadOffset;
-#endif
-  internal::Isolate* isolate = I::GetIsolateForSandbox(ctx);
+  int value_offset = I::kEmbedderDataArrayHeaderSize +
+                     (I::kEmbedderDataSlotSize * index) +
+                     I::kEmbedderDataSlotExternalPointerOffset;
+  Isolate* isolate = I::GetIsolateForSandbox(ctx);
   return reinterpret_cast<void*>(
-      I::ReadExternalPointerField(isolate, embedder_data, value_offset,
-                                  internal::kEmbedderDataSlotPayloadTag));
+      I::ReadExternalPointerField<internal::kEmbedderDataSlotPayloadTag>(
+          isolate, embedder_data, value_offset));
 #else
   return SlowGetAlignedPointerFromEmbedderData(index);
 #endif

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

@@ -82,6 +82,18 @@ struct V8_EXPORT CppHeapCreateParams {
 
   std::vector<std::unique_ptr<cppgc::CustomSpaceBase>> custom_spaces;
   WrapperDescriptor wrapper_descriptor;
+  /**
+   * Specifies which kind of marking are supported by the heap. The type may be
+   * further reduced via runtime flags when attaching the heap to an Isolate.
+   */
+  cppgc::Heap::MarkingType marking_support =
+      cppgc::Heap::MarkingType::kIncrementalAndConcurrent;
+  /**
+   * Specifies which kind of sweeping is supported by the heap. The type may be
+   * further reduced via runtime flags when attaching the heap to an Isolate.
+   */
+  cppgc::Heap::SweepingType sweeping_support =
+      cppgc::Heap::SweepingType::kIncrementalAndConcurrent;
 };
 
 /**

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

@@ -27,6 +27,11 @@ class V8_EXPORT Date : public Object {
    */
   double ValueOf() const;
 
+  /**
+   * Generates ISO string representation.
+   */
+  v8::Local<v8::String> ToISOString() const;
+
   V8_INLINE static Date* Cast(Value* value) {
 #ifdef V8_ENABLE_CHECKS
     CheckCast(value);

data/vendor/v8/include/v8-embedder-heap.h

@@ -69,7 +69,12 @@ class V8_EXPORT EmbedderRootsHandler {
  * trace through its heap and use reporter to report each JavaScript object
  * reachable from any of the given wrappers.
  */
-class V8_EXPORT EmbedderHeapTracer {
+class V8_EXPORT
+// GCC doesn't like combining __attribute__(()) with [[deprecated]].
+#ifdef __clang__
+V8_DEPRECATE_SOON("Use CppHeap when working with v8::TracedReference.")
+#endif  // __clang__
+    EmbedderHeapTracer {
  public:
   using EmbedderStackState = cppgc::EmbedderStackState;
 
@@ -205,10 +210,10 @@ class V8_EXPORT EmbedderHeapTracer {
    * Returns the v8::Isolate this tracer is attached too and |nullptr| if it
    * is not attached to any v8::Isolate.
    */
-  v8::Isolate* isolate() const { return isolate_; }
+  v8::Isolate* isolate() const { return v8_isolate_; }
 
  protected:
-  v8::Isolate* isolate_ = nullptr;
+  v8::Isolate* v8_isolate_ = nullptr;
 
   friend class internal::LocalEmbedderHeapTracer;
 };

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

@@ -197,7 +197,7 @@ class V8_EXPORT TryCatch {
 
   void ResetInternal();
 
-  internal::Isolate* isolate_;
+  internal::Isolate* i_isolate_;
   TryCatch* next_;
   void* exception_;
   void* message_obj_;

data/vendor/v8/include/v8-fast-api-calls.h

@@ -240,6 +240,7 @@ class CTypeInfo {
   enum class Type : uint8_t {
     kVoid,
     kBool,
+    kUint8,
     kInt32,
     kUint32,
     kInt64,
@@ -247,6 +248,7 @@ class CTypeInfo {
     kFloat32,
     kFloat64,
     kV8Value,
+    kSeqOneByteString,
     kApiObject,  // This will be deprecated once all users have
                  // migrated from v8::ApiObject to v8::Local<v8::Value>.
     kAny,        // This is added to enable untyped representation of fast
@@ -302,8 +304,9 @@ class CTypeInfo {
   constexpr Flags GetFlags() const { return flags_; }
 
   static constexpr bool IsIntegralType(Type type) {
-    return type == Type::kInt32 || type == Type::kUint32 ||
-           type == Type::kInt64 || type == Type::kUint64;
+    return type == Type::kUint8 || type == Type::kInt32 ||
+           type == Type::kUint32 || type == Type::kInt64 ||
+           type == Type::kUint64;
   }
 
   static constexpr bool IsFloatingPointType(Type type) {
@@ -377,6 +380,11 @@ struct FastApiArrayBuffer {
   size_t byte_length;
 };
 
+struct FastOneByteString {
+  const char* data;
+  uint32_t length;
+};
+
 class V8_EXPORT CFunctionInfo {
  public:
   // Construct a struct to hold a CFunction's type information.
@@ -429,12 +437,14 @@ struct AnyCType {
     double double_value;
     Local<Object> object_value;
     Local<Array> sequence_value;
+    const FastApiTypedArray<uint8_t>* uint8_ta_value;
     const FastApiTypedArray<int32_t>* int32_ta_value;
     const FastApiTypedArray<uint32_t>* uint32_ta_value;
     const FastApiTypedArray<int64_t>* int64_ta_value;
     const FastApiTypedArray<uint64_t>* uint64_ta_value;
     const FastApiTypedArray<float>* float_ta_value;
     const FastApiTypedArray<double>* double_ta_value;
+    const FastOneByteString* string_value;
     FastApiCallbackOptions* options_value;
   };
 };
@@ -544,7 +554,7 @@ struct FastApiCallbackOptions {
    * returned instance may be filled with mock data.
    */
   static FastApiCallbackOptions CreateForTesting(Isolate* isolate) {
-    return {false, {0}};
+    return {false, {0}, nullptr};
   }
 
   /**
@@ -566,8 +576,13 @@ struct FastApiCallbackOptions {
    */
   union {
     uintptr_t data_ptr;
-    v8::Value data;
+    v8::Local<v8::Value> data;
   };
+
+  /**
+   * When called from WebAssembly, a view of the calling module's memory.
+   */
+  FastApiTypedArray<uint8_t>* const wasm_memory;
 };
 
 namespace internal {
@@ -606,7 +621,7 @@ class CFunctionInfoImpl : public CFunctionInfo {
                       kReturnType == CTypeInfo::Type::kFloat32 ||
                       kReturnType == CTypeInfo::Type::kFloat64 ||
                       kReturnType == CTypeInfo::Type::kAny,
-                  "64-bit int and api object values are not currently "
+                  "64-bit int, string and api object values are not currently "
                   "supported return types.");
   }
 
@@ -648,7 +663,8 @@ struct CTypeInfoTraits {};
   V(int64_t, kInt64)         \
   V(uint64_t, kUint64)       \
   V(float, kFloat32)         \
-  V(double, kFloat64)
+  V(double, kFloat64)        \
+  V(uint8_t, kUint8)
 
 // Same as above, but includes deprecated types for compatibility.
 #define ALL_C_TYPES(V)               \
@@ -687,7 +703,8 @@ PRIMITIVE_C_TYPES(DEFINE_TYPE_INFO_TRAITS)
   V(int64_t, kInt64)           \
   V(uint64_t, kUint64)         \
   V(float, kFloat32)           \
-  V(double, kFloat64)
+  V(double, kFloat64)          \
+  V(uint8_t, kUint8)
 
 TYPED_ARRAY_C_TYPES(SPECIALIZE_GET_TYPE_INFO_HELPER_FOR_TA)
 
@@ -725,6 +742,18 @@ struct TypeInfoHelper<FastApiCallbackOptions&> {
   }
 };
 
+template <>
+struct TypeInfoHelper<const FastOneByteString&> {
+  static constexpr CTypeInfo::Flags Flags() { return CTypeInfo::Flags::kNone; }
+
+  static constexpr CTypeInfo::Type Type() {
+    return CTypeInfo::Type::kSeqOneByteString;
+  }
+  static constexpr CTypeInfo::SequenceType SequenceType() {
+    return CTypeInfo::SequenceType::kScalar;
+  }
+};
+
 #define STATIC_ASSERT_IMPLIES(COND, ASSERTION, MSG) \
   static_assert(((COND) == 0) || (ASSERTION), MSG)
 
@@ -802,6 +831,16 @@ class CFunctionBuilderWithFunction {
         std::make_index_sequence<sizeof...(ArgBuilders)>());
   }
 
+  // Provided for testing purposes.
+  template <typename Ret, typename... Args>
+  auto Patch(Ret (*patching_func)(Args...)) {
+    static_assert(
+        sizeof...(Args) == sizeof...(ArgBuilders),
+        "The patching function must have the same number of arguments.");
+    fn_ = reinterpret_cast<void*>(patching_func);
+    return *this;
+  }
+
   auto Build() {
     static CFunctionInfoImpl<RetBuilder, ArgBuilders...> instance;
     return CFunction(fn_, &instance);
@@ -881,31 +920,6 @@ static constexpr CTypeInfo kTypeInfoFloat64 =
  * to the requested destination type, is considered unsupported. The operation
  * returns true on success. `type_info` will be used for conversions.
  */
-template <const CTypeInfo* type_info, typename T>
-V8_DEPRECATED(
-    "Use TryToCopyAndConvertArrayToCppBuffer<CTypeInfo::Identifier, T>()")
-bool V8_EXPORT V8_WARN_UNUSED_RESULT
-    TryCopyAndConvertArrayToCppBuffer(Local<Array> src, T* dst,
-                                      uint32_t max_length);
-
-template <>
-V8_DEPRECATED(
-    "Use TryToCopyAndConvertArrayToCppBuffer<CTypeInfo::Identifier, T>()")
-inline bool V8_WARN_UNUSED_RESULT
-    TryCopyAndConvertArrayToCppBuffer<&kTypeInfoInt32, int32_t>(
-        Local<Array> src, int32_t* dst, uint32_t max_length) {
-  return false;
-}
-
-template <>
-V8_DEPRECATED(
-    "Use TryToCopyAndConvertArrayToCppBuffer<CTypeInfo::Identifier, T>()")
-inline bool V8_WARN_UNUSED_RESULT
-    TryCopyAndConvertArrayToCppBuffer<&kTypeInfoFloat64, double>(
-        Local<Array> src, double* dst, uint32_t max_length) {
-  return false;
-}
-
 template <CTypeInfo::Identifier type_info_id, typename T>
 bool V8_EXPORT V8_WARN_UNUSED_RESULT TryToCopyAndConvertArrayToCppBuffer(
     Local<Array> src, T* dst, uint32_t max_length);

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

@@ -106,6 +106,14 @@ class V8_EXPORT Function : public Object {
   V8_WARN_UNUSED_RESULT MaybeLocal<String> FunctionProtoToString(
       Local<Context> context);
 
+  /**
+   * Returns true if the function does nothing.
+   * The function returns false on error.
+   * Note that this function is experimental. Embedders should not rely on
+   * this existing. We may remove this function in the future.
+   */
+  V8_WARN_UNUSED_RESULT bool Experimental_IsNopFunction() const;
+
   ScriptOrigin GetScriptOrigin() const;
   V8_INLINE static Function* Cast(Value* value) {
 #ifdef V8_ENABLE_CHECKS