Add PromiseHook bindings

core/src/runtime.rs

@@ -20,8 +20,18 @@ pub(crate) use r#async::InnerRuntime;
 #[cfg(feature = "futures")]
 pub use r#async::{AsyncRuntime, AsyncWeakRuntime};
 
+use crate::value::promise::PromiseHookType;
 use crate::{Ctx, Value};
 
+/// The type of the promise hook.
+#[cfg(not(feature = "parallel"))]
+pub type PromiseHook =
+    Box<dyn for<'a> Fn(Ctx<'a>, PromiseHookType, Value<'a>, Value<'a>) + 'static>;
+/// The type of the promise hook.
+#[cfg(feature = "parallel")]
+pub type PromiseHook =
+    Box<dyn for<'a> Fn(Ctx<'a>, PromiseHookType, Value<'a>, Value<'a>) + Send + 'static>;
+
 /// The type of the promise rejection tracker.
 #[cfg(not(feature = "parallel"))]
 pub type RejectionTracker = Box<dyn for<'a> Fn(Ctx<'a>, Value<'a>, Value<'a>, bool) + 'static>;

core/src/runtime/async.rs

@@ -13,7 +13,7 @@ use async_lock::Mutex;
 
 use super::{
     opaque::Opaque, raw::RawRuntime, schedular::SchedularPoll, spawner::DriveFuture,
-    InterruptHandler, MemoryUsage,
+    InterruptHandler, MemoryUsage, PromiseHook,
 };
 use crate::allocator::Allocator;
 #[cfg(feature = "loader")]
@@ -160,6 +160,14 @@ impl AsyncRuntime {
         }
     }
 
+    /// Set a closure which is called when a promise is created, resolved, or chained.
+    #[inline]
+    pub async fn set_promise_hook(&self, tracker: Option<PromiseHook>) {
+        unsafe {
+            self.inner.lock().await.runtime.set_promise_hook(tracker);
+        }
+    }
+
     /// Set a closure which is regularly called by the engine when it is executing code.
     /// If the provided closure returns `true` the interpreter will raise and uncatchable
     /// exception and return control flow to the caller.

core/src/runtime/base.rs

@@ -1,6 +1,8 @@
 //! QuickJS runtime related types.
 
-use super::{opaque::Opaque, raw::RawRuntime, InterruptHandler, MemoryUsage, RejectionTracker};
+use super::{
+    opaque::Opaque, raw::RawRuntime, InterruptHandler, MemoryUsage, PromiseHook, RejectionTracker,
+};
 use crate::allocator::Allocator;
 #[cfg(feature = "loader")]
 use crate::loader::{Loader, Resolver};
@@ -61,6 +63,14 @@ impl Runtime {
         WeakRuntime(Ref::downgrade(&self.inner))
     }
 
+    /// Set a closure which is called when a promise is created, resolved, or chained.
+    #[inline]
+    pub fn set_promise_hook(&self, tracker: Option<PromiseHook>) {
+        unsafe {
+            self.inner.lock().set_promise_hook(tracker);
+        }
+    }
+
     /// Set a closure which is called when a Promise is rejected.
     #[inline]
     pub fn set_host_promise_rejection_tracker(&self, tracker: Option<RejectionTracker>) {

core/src/runtime/opaque.rs

@@ -5,7 +5,7 @@ use crate::{
 
 use super::{
     userdata::{UserDataGuard, UserDataMap},
-    InterruptHandler, RejectionTracker, UserDataError,
+    InterruptHandler, PromiseHook, PromiseHookType, RejectionTracker, UserDataError,
 };
 use std::{
     any::{Any, TypeId},
@@ -29,6 +29,9 @@ pub(crate) struct Opaque<'js> {
     /// Used to carry a panic if a callback triggered one.
     panic: Cell<Option<Box<dyn Any + Send + 'static>>>,
 
+    /// The user provided promise hook, if any.
+    promise_hook: UnsafeCell<Option<PromiseHook>>,
+
     /// The user provided rejection tracker, if any.
     rejection_tracker: UnsafeCell<Option<RejectionTracker>>,
 
@@ -55,6 +58,8 @@ impl<'js> Opaque<'js> {
         Opaque {
             panic: Cell::new(None),
 
+            promise_hook: UnsafeCell::new(None),
+
             rejection_tracker: UnsafeCell::new(None),
 
             interrupt_handler: UnsafeCell::new(None),
@@ -169,6 +174,20 @@ impl<'js> Opaque<'js> {
         self.userdata.get()
     }
 
+    pub fn set_promise_hook(&self, promise_hook: Option<PromiseHook>) {
+        unsafe { (*self.promise_hook.get()) = promise_hook }
+    }
+
+    pub fn run_promise_hook<'a>(
+        &self,
+        ctx: Ctx<'a>,
+        type_: PromiseHookType,
+        promise: Value<'a>,
+        parent: Value<'a>,
+    ) {
+        unsafe { (*self.promise_hook.get()).as_mut().unwrap()(ctx, type_, promise, parent) }
+    }
+
     pub fn set_rejection_tracker(&self, tracker: Option<RejectionTracker>) {
         unsafe { (*self.rejection_tracker.get()) = tracker }
     }

core/src/runtime/raw.rs

@@ -15,7 +15,7 @@ use crate::{
     Ctx, Error, Result, Value,
 };
 
-use super::{opaque::Opaque, InterruptHandler, RejectionTracker};
+use super::{opaque::Opaque, InterruptHandler, PromiseHook, PromiseHookType, RejectionTracker};
 
 const DUMP_BYTECODE_FINAL: u64 = 0x01;
 const DUMP_BYTECODE_PASS2: u64 = 0x02;
@@ -286,6 +286,49 @@ impl RawRuntime {
         stats.assume_init()
     }
 
+    pub unsafe fn set_promise_hook(&mut self, hook: Option<PromiseHook>) {
+        unsafe extern "C" fn promise_hook_wrapper(
+            ctx: *mut rquickjs_sys::JSContext,
+            type_: u32,
+            promise: rquickjs_sys::JSValue,
+            parent: rquickjs_sys::JSValue,
+            opaque: *mut ::std::os::raw::c_void,
+        ) {
+            let opaque = NonNull::new_unchecked(opaque).cast::<Opaque>();
+
+            let catch_unwind = panic::catch_unwind(AssertUnwindSafe(move || {
+                let ctx = Ctx::from_ptr(ctx);
+
+                let rtype = match type_ {
+                    qjs::JSPromiseHookType_JS_PROMISE_HOOK_INIT => PromiseHookType::Init,
+                    qjs::JSPromiseHookType_JS_PROMISE_HOOK_BEFORE => PromiseHookType::Before,
+                    qjs::JSPromiseHookType_JS_PROMISE_HOOK_AFTER => PromiseHookType::After,
+                    qjs::JSPromiseHookType_JS_PROMISE_HOOK_RESOLVE => PromiseHookType::Resolve,
+                    _ => unreachable!(),
+                };
+
+                opaque.as_ref().run_promise_hook(
+                    ctx.clone(),
+                    rtype,
+                    Value::from_js_value_const(ctx.clone(), promise),
+                    Value::from_js_value_const(ctx, parent),
+                );
+            }));
+            match catch_unwind {
+                Ok(_) => {}
+                Err(panic) => {
+                    opaque.as_ref().set_panic(panic);
+                }
+            }
+        }
+        qjs::JS_SetPromiseHook(
+            self.rt.as_ptr(),
+            hook.as_ref().map(|_| promise_hook_wrapper as _),
+            qjs::JS_GetRuntimeOpaque(self.rt.as_ptr()),
+        );
+        self.get_opaque().set_promise_hook(hook);
+    }
+
     pub unsafe fn set_host_promise_rejection_tracker(&mut self, tracker: Option<RejectionTracker>) {
         unsafe extern "C" fn rejection_tracker_wrapper(
             ctx: *mut rquickjs_sys::JSContext,

core/src/value.rs

@@ -342,7 +342,7 @@ impl<'js> Value<'js> {
     /// Check if the value is an array
     #[inline]
     pub fn is_array(&self) -> bool {
-        0 != unsafe { qjs::JS_IsArray(self.ctx.as_ptr(), self.value) }
+        unsafe { qjs::JS_IsArray(self.value) }
     }
 
     /// Check if the value is a function

core/src/value/promise.rs

@@ -25,6 +25,15 @@ pub enum PromiseState {
     Rejected,
 }
 
+/// The type of promise event.
+#[derive(Clone, Copy, Eq, PartialEq, Debug)]
+pub enum PromiseHookType {
+    Init,
+    Before,
+    After,
+    Resolve,
+}
+
 /// A JavaScript promise.
 #[derive(Debug, PartialEq, Clone, Hash, Eq)]
 #[repr(transparent)]

sys/build.rs

@@ -121,7 +121,8 @@ fn main() {
     let out_dir = Path::new(&out_dir);
 
     let header_files = [
-        "libbf.h",
+        "builtin-array-fromasync.h",
+        "xsum.h",
         "libregexp-opcode.h",
         "libregexp.h",
         "libunicode-table.h",
@@ -139,7 +140,7 @@ fn main() {
         "libunicode.c",
         "cutils.c",
         "quickjs.c",
-        "libbf.c",
+        "xsum.c",
     ];
 
     let mut defines: Vec<(String, Option<&str>)> = vec![("_GNU_SOURCE".into(), None)];