refactor(core): remove unneeded ops for uncaughtException (#15296)

1 files changed, 6 insertions, 50 deletions

diff --git a/core/runtime.rs b/core/runtime.rs
index 4568f2018..0176ff791 100644
--- a/core/runtime.rs
+++ b/core/runtime.rs
@@ -154,7 +154,6 @@ pub(crate) struct JsRuntimeState {
   pub(crate) js_macrotask_cbs: Vec<v8::Global<v8::Function>>,
   pub(crate) js_nexttick_cbs: Vec<v8::Global<v8::Function>>,
   pub(crate) js_promise_reject_cb: Option<v8::Global<v8::Function>>,
-  pub(crate) js_uncaught_exception_cb: Option<v8::Global<v8::Function>>,
   pub(crate) js_format_exception_cb: Option<v8::Global<v8::Function>>,
   pub(crate) has_tick_scheduled: bool,
   pub(crate) js_wasm_streaming_cb: Option<v8::Global<v8::Function>>,
@@ -394,7 +393,6 @@ impl JsRuntime {
       js_macrotask_cbs: vec![],
       js_nexttick_cbs: vec![],
       js_promise_reject_cb: None,
-      js_uncaught_exception_cb: None,
       js_format_exception_cb: None,
       has_tick_scheduled: false,
       js_wasm_streaming_cb: None,
@@ -3211,7 +3209,6 @@ assertEquals(1, notify_return_value);
   #[tokio::test]
   async fn test_set_promise_reject_callback() {
     static PROMISE_REJECT: AtomicUsize = AtomicUsize::new(0);
-    static UNCAUGHT_EXCEPTION: AtomicUsize = AtomicUsize::new(0);
 
     #[op]
     fn op_promise_reject() -> Result<(), AnyError> {
@@ -3219,17 +3216,8 @@ assertEquals(1, notify_return_value);
       Ok(())
     }
 
-    #[op]
-    fn op_uncaught_exception() -> Result<(), AnyError> {
-      UNCAUGHT_EXCEPTION.fetch_add(1, Ordering::Relaxed);
-      Ok(())
-    }
-
     let extension = Extension::builder()
-      .ops(vec![
-        op_promise_reject::decl(),
-        op_uncaught_exception::decl(),
-      ])
+      .ops(vec![op_promise_reject::decl()])
       .build();
 
     let mut runtime = JsRuntime::new(RuntimeOptions {
@@ -3249,23 +3237,17 @@ assertEquals(1, notify_return_value);
           if (reason.message !== "reject") {
             throw Error("unexpected reason: " + reason);
           }
+          Deno.core.opSync("op_store_pending_promise_exception", promise);
           Deno.core.opSync("op_promise_reject");
-          throw Error("promiseReject"); // Triggers uncaughtException handler.
-        });
-
-        Deno.core.opSync("op_set_uncaught_exception_callback", (err) => {
-          if (err.message !== "promiseReject") throw err;
-          Deno.core.opSync("op_uncaught_exception");
         });
 
         new Promise((_, reject) => reject(Error("reject")));
         "#,
       )
       .unwrap();
-    runtime.run_event_loop(false).await.unwrap();
+    runtime.run_event_loop(false).await.unwrap_err();
 
     assert_eq!(1, PROMISE_REJECT.load(Ordering::Relaxed));
-    assert_eq!(1, UNCAUGHT_EXCEPTION.load(Ordering::Relaxed));
 
     runtime
       .execute_script(
@@ -3277,29 +3259,18 @@ assertEquals(1, notify_return_value);
           });
         }
 
-        {
-          const prev = Deno.core.opSync("op_set_uncaught_exception_callback", (...args) => {
-            prev(...args);
-            throw Error("fail");
-          });
-        }
-
         new Promise((_, reject) => reject(Error("reject")));
         "#,
       )
       .unwrap();
-    // Exception from uncaughtException handler doesn't bubble up but is
-    // printed to stderr.
-    runtime.run_event_loop(false).await.unwrap();
+    runtime.run_event_loop(false).await.unwrap_err();
 
     assert_eq!(2, PROMISE_REJECT.load(Ordering::Relaxed));
-    assert_eq!(2, UNCAUGHT_EXCEPTION.load(Ordering::Relaxed));
   }
 
   #[tokio::test]
   async fn test_set_promise_reject_callback_top_level_await() {
     static PROMISE_REJECT: AtomicUsize = AtomicUsize::new(0);
-    static UNCAUGHT_EXCEPTION: AtomicUsize = AtomicUsize::new(0);
 
     #[op]
     fn op_promise_reject() -> Result<(), AnyError> {
@@ -3307,17 +3278,8 @@ assertEquals(1, notify_return_value);
       Ok(())
     }
 
-    #[op]
-    fn op_uncaught_exception() -> Result<(), AnyError> {
-      UNCAUGHT_EXCEPTION.fetch_add(1, Ordering::Relaxed);
-      Ok(())
-    }
-
     let extension = Extension::builder()
-      .ops(vec![
-        op_promise_reject::decl(),
-        op_uncaught_exception::decl(),
-      ])
+      .ops(vec![op_promise_reject::decl()])
       .build();
 
     #[derive(Default)]
@@ -3345,11 +3307,6 @@ assertEquals(1, notify_return_value);
         let source = r#"
         Deno.core.opSync("op_set_promise_reject_callback", (type, promise, reason) => {
           Deno.core.opSync("op_promise_reject");
-          throw reason;
-        });
-        
-        Deno.core.opSync("op_set_uncaught_exception_callback", (err) => {
-          Deno.core.opSync("op_uncaught_exception");
         });
         
         throw new Error('top level throw');
@@ -3379,10 +3336,9 @@ assertEquals(1, notify_return_value);
       .unwrap();
     let receiver = runtime.mod_evaluate(id);
     runtime.run_event_loop(false).await.unwrap();
-    receiver.await.unwrap().unwrap();
+    receiver.await.unwrap().unwrap_err();
 
     assert_eq!(1, PROMISE_REJECT.load(Ordering::Relaxed));
-    assert_eq!(1, UNCAUGHT_EXCEPTION.load(Ordering::Relaxed));
   }
 
   #[test]