4 files changed, 9 insertions, 59 deletions
diff --git a/core/01_core.js b/core/01_core.js
index 21376b695..156300327 100644
--- a/core/01_core.js
+++ b/core/01_core.js
@@ -268,10 +268,6 @@
     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 47632d00d..a88e54af7 100644
--- a/core/bindings.rs
+++ b/core/bindings.rs
@@ -282,6 +282,14 @@ 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();
     drop(state); // Drop borrow, callbacks can call back into runtime.
@@ -315,7 +323,6 @@ 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.
@@ -333,6 +340,7 @@ 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.rs b/core/ops_builtin.rs
index 53f2bd706..a42c0bae8 100644
--- a/core/ops_builtin.rs
+++ b/core/ops_builtin.rs
@@ -38,7 +38,6 @@ pub(crate) fn init_builtins() -> Extension {
       op_metrics::decl(),
       op_format_file_name::decl(),
       op_is_proxy::decl(),
-      op_next_task::decl(),
     ])
     .ops(crate::ops_builtin_v8::init_builtins_v8())
     .build()
@@ -190,8 +189,3 @@ fn op_format_file_name(file_name: String) -> String {
 fn op_is_proxy(value: serde_v8::Value) -> bool {
   value.v8_value.is_proxy()
 }
-
-/// Empty op that when awaited forces a macrotask to run. Useful for
-/// "unhandledrejection" event.
-#[op]
-async fn op_next_task() {}
diff --git a/core/ops_builtin_v8.rs b/core/ops_builtin_v8.rs
index 8af50f860..4bc80faa5 100644
--- a/core/ops_builtin_v8.rs
+++ b/core/ops_builtin_v8.rs
@@ -48,9 +48,6 @@ 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(),
   ]
 }
 
@@ -813,48 +810,3 @@ fn op_event_loop_has_more_work(scope: &mut v8::HandleScope) -> bool {
     || has_pending_background_tasks
     || has_tick_scheduled
 }
-
-#[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)
-}