libv8-node 22.7.0.4-aarch64-linux → 23.6.1.0-aarch64-linux

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

@@ -8,6 +8,7 @@
 #include <stddef.h>
 
 #include "v8-local-handle.h"  // NOLINT(build/include_directory)
+#include "v8-object.h"        // NOLINT(build/include_directory)
 #include "v8config.h"         // NOLINT(build/include_directory)
 
 namespace v8 {
@@ -58,8 +59,77 @@ class V8_EXPORT Exception {
    * of a given exception, or an empty handle if not available.
    */
   static Local<StackTrace> GetStackTrace(Local<Value> exception);
+
+  /**
+   * Captures the current stack trace and attaches it to the given object in the
+   * form of `stack` property.
+   */
+  static Maybe<bool> CaptureStackTrace(Local<Context> context,
+                                       Local<Object> object);
 };
 
+/**
+ * This is a part of experimental Api and might be changed without further
+ * notice.
+ * Do not use it.
+ */
+enum class ExceptionContext : uint32_t {
+  kUnknown,
+  kConstructor,
+  kOperation,
+  kAttributeGet,
+  kAttributeSet,
+  kIndexedQuery,
+  kIndexedGetter,
+  kIndexedDescriptor,
+  kIndexedSetter,
+  kIndexedDefiner,
+  kIndexedDeleter,
+  kNamedQuery,
+  kNamedGetter,
+  kNamedDescriptor,
+  kNamedSetter,
+  kNamedDefiner,
+  kNamedDeleter,
+  kNamedEnumerator
+};
+
+/**
+ * This is a part of experimental Api and might be changed without further
+ * notice.
+ * Do not use it.
+ */
+class ExceptionPropagationMessage {
+ public:
+  ExceptionPropagationMessage(v8::Isolate* isolate, Local<Object> exception,
+                              Local<String> interface_name,
+                              Local<String> property_name,
+                              ExceptionContext exception_context)
+      : isolate_(isolate),
+        exception_(exception),
+        interface_name_(interface_name),
+        property_name_(property_name),
+        exception_context_(exception_context) {}
+
+  V8_INLINE Isolate* GetIsolate() const { return isolate_; }
+  V8_INLINE Local<Object> GetException() const { return exception_; }
+  V8_INLINE Local<String> GetInterfaceName() const { return interface_name_; }
+  V8_INLINE Local<String> GetPropertyName() const { return property_name_; }
+  V8_INLINE ExceptionContext GetExceptionContext() const {
+    return exception_context_;
+  }
+
+ private:
+  Isolate* isolate_;
+  Local<Object> exception_;
+  Local<String> interface_name_;
+  Local<String> property_name_;
+  ExceptionContext exception_context_;
+};
+
+using ExceptionPropagationCallback =
+    void (*)(ExceptionPropagationMessage message);
+
 /**
  * An external exception handler.
  */

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

@@ -337,7 +337,13 @@ struct FastApiTypedArrayBase {
 };
 
 template <typename T>
-struct FastApiTypedArray : public FastApiTypedArrayBase {
+struct V8_DEPRECATE_SOON(
+    "When an API function expects a TypedArray as a parameter, the type in the "
+    "signature should be `v8::Local<v8::Value>` instead of "
+    "FastApiTypedArray<>. The API function then has to type-check the "
+    "parameter and convert it to a `v8::Local<v8::TypedArray` to access the "
+    "data. In essence, the parameter should be handled the same as for a "
+    "regular API call.") FastApiTypedArray : public FastApiTypedArrayBase {
  public:
   V8_INLINE T get(size_t index) const {
 #ifdef DEBUG
@@ -458,13 +464,6 @@ union V8_TRIVIAL_ABI AnyCType {
   void* pointer_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;
 };
@@ -529,16 +528,22 @@ class V8_EXPORT CFunction {
   }
 
   template <typename F>
-  static CFunction Make(F* func) {
-    return ArgUnwrap<F*>::Make(func);
+  static CFunction Make(F* func,
+                        CFunctionInfo::Int64Representation int64_rep =
+                            CFunctionInfo::Int64Representation::kNumber) {
+    CFunction result = ArgUnwrap<F*>::Make(func, int64_rep);
+    result.GetInt64Representation();
+    return result;
   }
 
   // Provided for testing purposes.
   template <typename R, typename... Args, typename R_Patch,
             typename... Args_Patch>
   static CFunction Make(R (*func)(Args...),
-                        R_Patch (*patching_func)(Args_Patch...)) {
-    CFunction c_func = ArgUnwrap<R (*)(Args...)>::Make(func);
+                        R_Patch (*patching_func)(Args_Patch...),
+                        CFunctionInfo::Int64Representation int64_rep =
+                            CFunctionInfo::Int64Representation::kNumber) {
+    CFunction c_func = ArgUnwrap<R (*)(Args...)>::Make(func, int64_rep);
     static_assert(
         sizeof...(Args_Patch) == sizeof...(Args),
         "The patching function must have the same number of arguments.");
@@ -561,7 +566,9 @@ class V8_EXPORT CFunction {
   template <typename R, typename... Args>
   class ArgUnwrap<R (*)(Args...)> {
    public:
-    static CFunction Make(R (*func)(Args...));
+    static CFunction Make(R (*func)(Args...),
+                          CFunctionInfo::Int64Representation int64_rep =
+                              CFunctionInfo::Int64Representation::kNumber);
   };
 };
 
@@ -577,35 +584,15 @@ struct FastApiCallbackOptions {
    * returned instance may be filled with mock data.
    */
   static FastApiCallbackOptions CreateForTesting(Isolate* isolate) {
-    return {false, {0}, nullptr};
+    return {};
   }
 
-  /**
-   * If the callback wants to signal an error condition or to perform an
-   * allocation, it must set options.fallback to true and do an early return
-   * from the fast method. Then V8 checks the value of options.fallback and if
-   * it's true, falls back to executing the SlowCallback, which is capable of
-   * reporting the error (either by throwing a JS exception or logging to the
-   * console) or doing the allocation. It's the embedder's responsibility to
-   * ensure that the fast callback is idempotent up to the point where error and
-   * fallback conditions are checked, because otherwise executing the slow
-   * callback might produce visible side-effects twice.
-   */
-  bool fallback;
+  v8::Isolate* isolate = nullptr;
 
   /**
    * The `data` passed to the FunctionTemplate constructor, or `undefined`.
-   * `data_ptr` allows for default constructing FastApiCallbackOptions.
    */
-  union {
-    uintptr_t data_ptr;
-    v8::Local<v8::Value> data;
-  };
-
-  /**
-   * When called from WebAssembly, a view of the calling module's memory.
-   */
-  FastApiTypedArray<uint8_t>* const wasm_memory;
+  v8::Local<v8::Value> data;
 };
 
 namespace internal {
@@ -929,8 +916,14 @@ class CFunctionBuilder {
 
 // static
 template <typename R, typename... Args>
-CFunction CFunction::ArgUnwrap<R (*)(Args...)>::Make(R (*func)(Args...)) {
-  return internal::CFunctionBuilder().Fn(func).Build();
+CFunction CFunction::ArgUnwrap<R (*)(Args...)>::Make(
+    R (*func)(Args...), CFunctionInfo::Int64Representation int64_rep) {
+  if (int64_rep == CFunctionInfo::Int64Representation::kNumber) {
+    return internal::CFunctionBuilder().Fn(func).Build();
+  }
+  return internal::CFunctionBuilder()
+      .Fn(func)
+      .template Build<CFunctionInfo::Int64Representation::kBigInt>();
 }
 
 using CFunctionBuilder = internal::CFunctionBuilder;