Reland "feat: add "unhandledrejection" event support" (#15211)

3 files changed, 85 insertions, 18 deletions

diff --git a/core/01_core.js b/core/01_core.js
index 156300327..21376b695 100644
--- a/core/01_core.js
+++ b/core/01_core.js
@@ -268,6 +268,10 @@
     terminate: opSync.bind(null, "op_terminate"),
     opNames: opSync.bind(null, "op_op_names"),
     eventLoopHasMoreWork: opSync.bind(null, "op_event_loop_has_more_work"),
+    setPromiseRejectCallback: opSync.bind(
+      null,
+      "op_set_promise_reject_callback",
+    ),
   });
 
   ObjectAssign(globalThis.__bootstrap, { core });
diff --git a/core/bindings.rs b/core/bindings.rs
index 66c3e436d..6fa9f745b 100644
--- a/core/bindings.rs
+++ b/core/bindings.rs
@@ -323,14 +323,6 @@ pub extern "C" fn promise_reject_callback(message: v8::PromiseRejectMessage) {
   let state_rc = JsRuntime::state(scope);
   let mut state = state_rc.borrow_mut();
 
-  // Node compat: perform synchronous process.emit("unhandledRejection").
-  //
-  // Note the callback follows the (type, promise, reason) signature of Node's
-  // internal promiseRejectHandler from lib/internal/process/promises.js, not
-  // the (promise, reason) signature of the "unhandledRejection" event listener.
-  //
-  // Short-circuits Deno's regular unhandled rejection logic because that's
-  // a) asynchronous, and b) always terminates.
   if let Some(js_promise_reject_cb) = state.js_promise_reject_cb.clone() {
     let js_uncaught_exception_cb = state.js_uncaught_exception_cb.clone();
 
@@ -338,14 +330,6 @@ pub extern "C" fn promise_reject_callback(message: v8::PromiseRejectMessage) {
     let undefined: v8::Local<v8::Value> = v8::undefined(tc_scope).into();
     let type_ = v8::Integer::new(tc_scope, message.get_event() as i32);
     let promise = message.get_promise();
-    if let Some(pending_mod_evaluate) = state.pending_mod_evaluate.as_mut() {
-      if !pending_mod_evaluate.has_evaluated {
-        let promise_global = v8::Global::new(tc_scope, promise);
-        pending_mod_evaluate
-          .handled_promise_rejections
-          .push(promise_global);
-      }
-    }
     drop(state); // Drop borrow, callbacks can call back into runtime.
 
     let reason = match message.get_event() {
@@ -355,14 +339,45 @@ pub extern "C" fn promise_reject_callback(message: v8::PromiseRejectMessage) {
       PromiseHandlerAddedAfterReject => undefined,
     };
 
+    let promise_global = v8::Global::new(tc_scope, promise);
     let args = &[type_.into(), promise.into(), reason];
-    js_promise_reject_cb
+    let maybe_has_unhandled_rejection_handler = js_promise_reject_cb
       .open(tc_scope)
       .call(tc_scope, undefined, args);
 
+    let has_unhandled_rejection_handler =
+      if let Some(value) = maybe_has_unhandled_rejection_handler {
+        value.is_true()
+      } else {
+        false
+      };
+
+    if has_unhandled_rejection_handler {
+      let mut state = state_rc.borrow_mut();
+      if let Some(pending_mod_evaluate) = state.pending_mod_evaluate.as_mut() {
+        if !pending_mod_evaluate.has_evaluated {
+          pending_mod_evaluate
+            .handled_promise_rejections
+            .push(promise_global.clone());
+        }
+      }
+    }
+
     if let Some(exception) = tc_scope.exception() {
       if let Some(js_uncaught_exception_cb) = js_uncaught_exception_cb {
         tc_scope.reset(); // Cancel pending exception.
+        {
+          let mut state = state_rc.borrow_mut();
+          if let Some(pending_mod_evaluate) =
+            state.pending_mod_evaluate.as_mut()
+          {
+            if !pending_mod_evaluate.has_evaluated {
+              pending_mod_evaluate
+                .handled_promise_rejections
+                .push(promise_global);
+            }
+          }
+        }
         js_uncaught_exception_cb.open(tc_scope).call(
           tc_scope,
           undefined,
@@ -372,6 +387,7 @@ pub extern "C" fn promise_reject_callback(message: v8::PromiseRejectMessage) {
     }
 
     if tc_scope.has_caught() {
+      // TODO(bartlomieju): ensure that TODO provided below is still valid.
       // If we get here, an exception was thrown by the unhandledRejection
       // handler and there is ether no uncaughtException handler or the
       // handler threw an exception of its own.
@@ -389,7 +405,6 @@ pub extern "C" fn promise_reject_callback(message: v8::PromiseRejectMessage) {
   } else {
     let promise = message.get_promise();
     let promise_global = v8::Global::new(scope, promise);
-
     match message.get_event() {
       PromiseRejectWithNoHandler => {
         let error = message.get_value().unwrap();
diff --git a/core/ops_builtin_v8.rs b/core/ops_builtin_v8.rs
index 39469c0ad..a17e273f3 100644
--- a/core/ops_builtin_v8.rs
+++ b/core/ops_builtin_v8.rs
@@ -48,6 +48,9 @@ pub(crate) fn init_builtins_v8() -> Vec<OpDecl> {
     op_apply_source_map::decl(),
     op_set_format_exception_callback::decl(),
     op_event_loop_has_more_work::decl(),
+    op_store_pending_promise_exception::decl(),
+    op_remove_pending_promise_exception::decl(),
+    op_has_pending_promise_exception::decl(),
   ]
 }
 
@@ -792,3 +795,48 @@ fn op_set_format_exception_callback<'a>(
 fn op_event_loop_has_more_work(scope: &mut v8::HandleScope) -> bool {
   JsRuntime::event_loop_pending_state(scope).is_pending()
 }
+
+#[op(v8)]
+fn op_store_pending_promise_exception<'a>(
+  scope: &mut v8::HandleScope<'a>,
+  promise: serde_v8::Value<'a>,
+  reason: serde_v8::Value<'a>,
+) {
+  let state_rc = JsRuntime::state(scope);
+  let mut state = state_rc.borrow_mut();
+  let promise_value =
+    v8::Local::<v8::Promise>::try_from(promise.v8_value).unwrap();
+  let promise_global = v8::Global::new(scope, promise_value);
+  let error_global = v8::Global::new(scope, reason.v8_value);
+  state
+    .pending_promise_exceptions
+    .insert(promise_global, error_global);
+}
+
+#[op(v8)]
+fn op_remove_pending_promise_exception<'a>(
+  scope: &mut v8::HandleScope<'a>,
+  promise: serde_v8::Value<'a>,
+) {
+  let state_rc = JsRuntime::state(scope);
+  let mut state = state_rc.borrow_mut();
+  let promise_value =
+    v8::Local::<v8::Promise>::try_from(promise.v8_value).unwrap();
+  let promise_global = v8::Global::new(scope, promise_value);
+  state.pending_promise_exceptions.remove(&promise_global);
+}
+
+#[op(v8)]
+fn op_has_pending_promise_exception<'a>(
+  scope: &mut v8::HandleScope<'a>,
+  promise: serde_v8::Value<'a>,
+) -> bool {
+  let state_rc = JsRuntime::state(scope);
+  let state = state_rc.borrow();
+  let promise_value =
+    v8::Local::<v8::Promise>::try_from(promise.v8_value).unwrap();
+  let promise_global = v8::Global::new(scope, promise_value);
+  state
+    .pending_promise_exceptions
+    .contains_key(&promise_global)
+}