refactor: Clean up error handling

Author: marc2332

cli/src/main.rs

@@ -6,7 +6,6 @@ use andromeda_runtime::{
     recommended_builtins, recommended_eventloop_handler, recommended_extensions,
 };
 use clap::{Parser as ClapParser, Subcommand};
-use nova_vm::engine::context::Bindable;
 /// A JavaScript runtime
 #[derive(Debug, ClapParser)]
 #[command(name = "andromeda")]
@@ -50,24 +49,32 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             no_strict,
             paths,
         } => {
-            let mut runtime = Runtime::new(RuntimeConfig {
+            let runtime = Runtime::new(RuntimeConfig {
                 no_strict,
                 paths,
                 verbose,
                 extensions: recommended_extensions(),
                 builtins: recommended_builtins(),
                 eventloop_handler: recommended_eventloop_handler,
             });
-            let runtime_result = runtime.run(|agent, gc, error| {
-                eprintln!(
-                    "Uncaught exception: {}",
-                    error.value().unbind().string_repr(agent, gc).as_str(agent)
-                );
-            });
+            let mut runtime_output = runtime.run();
 
-            if let Ok(result) = runtime_result {
-                if verbose {
-                    println!("{:?}", result);
+            match runtime_output.result {
+                Ok(result) => {
+                    if verbose {
+                        println!("{:?}", result);
+                    }
+                }
+                Err(error) => {
+                    runtime_output
+                        .agent
+                        .run_in_realm(&runtime_output.realm_root, |agent, gc| {
+                            eprintln!(
+                                "Uncaught exception: {}",
+                                error.value().string_repr(agent, gc).as_str(agent)
+                            );
+                            std::process::exit(1);
+                        })
                 }
             }
         }

core/src/runtime.rs

@@ -11,7 +11,7 @@ use nova_vm::{
         builtins::promise_objects::promise_abstract_operations::promise_capability_records::PromiseCapability,
         execution::{
             Agent, JsResult,
-            agent::{GcAgent, HostHooks, Job, JsError, Options, RealmRoot},
+            agent::{GcAgent, HostHooks, Job, Options, RealmRoot},
         },
         scripts_and_modules::script::{parse_script, script_evaluation},
         types::{self, Object, Value},
@@ -130,10 +130,7 @@ impl<UserMacroTask> Runtime<UserMacroTask> {
     }
 
     /// Run the Runtime with the specified configuration.
-    pub fn run(
-        &mut self,
-        mut error_handler: impl FnMut(&mut Agent, GcScope, JsError<'static>),
-    ) -> JsResult<Value<'static>> {
+    pub fn run(mut self) -> RuntimeOutput {
         // Load the builtins js sources
         self.agent.run_in_realm(&self.realm_root, |agent, mut gc| {
             for builtin in &self.config.builtins {
@@ -157,13 +154,13 @@ impl<UserMacroTask> Runtime<UserMacroTask> {
             }
         });
 
-        let mut final_result = Value::<'static>::Null;
+        let mut result = JsResult::Ok(Value::Null);
 
         // Fetch the runtime mod.ts file using a macro and add it to the paths
         for path in &self.config.paths {
             let file = std::fs::read_to_string(path).unwrap();
 
-            final_result = self.agent.run_in_realm(&self.realm_root, |agent, mut gc| {
+            result = self.agent.run_in_realm(&self.realm_root, |agent, mut gc| {
                 let source_text = types::String::from_string(agent, file, gc.nogc());
                 let realm = agent.current_realm(gc.nogc());
 
@@ -179,28 +176,15 @@ impl<UserMacroTask> Runtime<UserMacroTask> {
                     Err(errors) => exit_with_parse_errors(errors, path, source_text.as_str(agent)),
                 };
 
-                let res = script_evaluation(agent, script.unbind(), gc.reborrow())
-                    .map(move |v| v.unbind())
-                    .unbind();
-                if let Err(err) = res {
-                    error_handler(agent, gc.reborrow(), err);
-                }
-                res
-            })?;
+                script_evaluation(agent, script.unbind(), gc.reborrow()).unbind()
+            });
         }
 
         loop {
             while let Some(job) = self.host_hooks.pop_promise_job() {
-                self.agent.run_in_realm(&self.realm_root, |agent, mut gc| {
-                    let res = job
-                        .run(agent, gc.reborrow())
-                        .map(move |v| v.unbind())
-                        .unbind();
-                    if let Err(err) = res {
-                        error_handler(agent, gc, err);
-                    }
-                    res
-                })?;
+                result = self.agent.run_in_realm(&self.realm_root, |agent, mut gc| {
+                    job.run(agent, gc.reborrow()).unbind().map(|_| Value::Null)
+                });
             }
 
             // If both the microtasks and macrotasks queues are empty we can end the event loop
@@ -211,7 +195,11 @@ impl<UserMacroTask> Runtime<UserMacroTask> {
             self.handle_macro_task();
         }
 
-        Ok(final_result)
+        RuntimeOutput {
+            agent: self.agent,
+            realm_root: self.realm_root,
+            result,
+        }
     }
 
     // Listen for pending macro tasks and resolve one by one
@@ -241,3 +229,9 @@ impl<UserMacroTask> Runtime<UserMacroTask> {
         }
     }
 }
+
+pub struct RuntimeOutput {
+    pub agent: GcAgent,
+    pub realm_root: RealmRoot,
+    pub result: JsResult<'static, Value<'static>>,
+}