Merge pull request #46 from tryandromeda/feat/nova-mid-april

feat: Update with Nova changes (mid April)

Author: marc2332

Cargo.lock

@@ -18,7 +18,7 @@ anymap = "0.12.1"
 clap = { version = "4.5.23", features = ["derive"] }
 cliclack = "0.3.5"
 console = "0.15.8"
-nova_vm = { git = "https://github.com/trynova/nova", branch = "main", features = ["typescript"] }
+nova_vm = { git = "https://github.com/trynova/nova", rev = "393be1488c62951b6b9cd5b321d9f36c80f16c70", features = ["typescript"] }
 oxc_ast = "0.51.0"
 oxc_diagnostics = "0.51.0"
 oxc-miette = { version = "1.0.2", features = ["fancy"] }

Cargo.toml

@@ -49,31 +49,33 @@ 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();
+            let mut runtime_output = runtime.run();
 
-            match runtime_result {
+            match runtime_output.result {
                 Ok(result) => {
                     if verbose {
                         println!("{:?}", result);
                     }
                 }
-                Err(error) => runtime
-                    .agent
-                    .run_in_realm(&runtime.realm_root, |agent, gc| {
-                        eprintln!(
-                            "Uncaught exception: {}",
-                            error.value().string_repr(agent, gc).as_str(agent)
-                        );
-                        std::process::exit(1);
-                    }),
+                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);
+                        })
+                }
             }
         }
     });

cli/src/main.rs

@@ -4,7 +4,7 @@ use nova_vm::{ecmascript::types::Value, engine::Global};
 #[derive(Debug)]
 pub enum MacroTask<UserMacroTask> {
     /// Resolve a promise.
-    ResolvePromise(Global<Value>),
+    ResolvePromise(Global<Value<'static>>),
     /// User-defined macro task.
     User(UserMacroTask),
 }

core/src/event_loop.rs

@@ -5,7 +5,7 @@ use nova_vm::{
         scripts_and_modules::script::{parse_script, script_evaluation},
         types::{InternalMethods, IntoValue, Object, PropertyDescriptor, PropertyKey},
     },
-    engine::context::GcScope,
+    engine::context::{Bindable, GcScope},
 };
 
 use crate::{HostData, OpsStorage, exit_with_parse_errors};
@@ -55,15 +55,15 @@ impl Extension {
             let script = match parse_script(
                 agent,
                 source_text,
-                agent.current_realm_id(),
+                agent.current_realm(gc.nogc()),
                 true,
                 None,
                 gc.nogc(),
             ) {
                 Ok(script) => script,
                 Err(diagnostics) => exit_with_parse_errors(diagnostics, "<runtime>", file),
             };
-            match script_evaluation(agent, script, gc.reborrow()) {
+            match script_evaluation(agent, script.unbind(), gc.reborrow()) {
                 Ok(_) => (),
                 Err(_) => println!("Error in runtime"),
             }
@@ -72,7 +72,7 @@ impl Extension {
             let function = create_builtin_function(
                 agent,
                 Behaviour::Regular(op.function),
-                BuiltinFunctionArgs::new(op.args, op.name, agent.current_realm_id()),
+                BuiltinFunctionArgs::new(op.args, op.name),
                 gc.nogc(),
             );
             function.unbind();
@@ -82,7 +82,7 @@ impl Extension {
                     agent,
                     property_key.unbind(),
                     PropertyDescriptor {
-                        value: Some(function.into_value()),
+                        value: Some(function.into_value().unbind()),
                         ..Default::default()
                     },
                     gc.reborrow(),

core/src/extension.rs

@@ -16,7 +16,7 @@ use nova_vm::{
         scripts_and_modules::script::{parse_script, script_evaluation},
         types::{self, Object, Value},
     },
-    engine::context::GcScope,
+    engine::context::{Bindable, GcScope},
 };
 
 use crate::{Extension, HostData, MacroTask, exit_with_parse_errors};
@@ -130,11 +130,11 @@ impl<UserMacroTask> Runtime<UserMacroTask> {
     }
 
     /// Run the Runtime with the specified configuration.
-    pub fn run(&mut self) -> JsResult<Value> {
+    pub fn run(mut self) -> RuntimeOutput {
         // Load the builtins js sources
         self.agent.run_in_realm(&self.realm_root, |agent, mut gc| {
-            let realm = agent.current_realm_id();
             for builtin in &self.config.builtins {
+                let realm = agent.current_realm(gc.nogc());
                 let source_text = types::String::from_str(agent, builtin, gc.nogc());
                 let script = match parse_script(
                     agent,
@@ -147,22 +147,22 @@ impl<UserMacroTask> Runtime<UserMacroTask> {
                     Ok(script) => script,
                     Err(diagnostics) => exit_with_parse_errors(diagnostics, "<runtime>", builtin),
                 };
-                match script_evaluation(agent, script, gc.reborrow()) {
+                match script_evaluation(agent, script.unbind(), gc.reborrow()) {
                     Ok(_) => (),
                     Err(_) => println!("Error in runtime"),
                 }
             }
         });
 
-        let mut final_result = Value::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, 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_id();
+                let realm = agent.current_realm(gc.nogc());
 
                 let script = match parse_script(
                     agent,
@@ -176,14 +176,15 @@ impl<UserMacroTask> Runtime<UserMacroTask> {
                     Err(errors) => exit_with_parse_errors(errors, path, source_text.as_str(agent)),
                 };
 
-                script_evaluation(agent, script, gc)
-            })?;
+                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, gc| job.run(agent, gc))?;
+                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
@@ -194,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
@@ -224,3 +229,9 @@ impl<UserMacroTask> Runtime<UserMacroTask> {
         }
     }
 }
+
+pub struct RuntimeOutput {
+    pub agent: GcAgent,
+    pub realm_root: RealmRoot,
+    pub result: JsResult<'static, Value<'static>>,
+}

core/src/runtime.rs

@@ -7,7 +7,7 @@ use nova_vm::{
         execution::{Agent, JsResult},
         types::Value,
     },
-    engine::context::GcScope,
+    engine::context::{Bindable, GcScope},
 };
 
 #[derive(Default)]
@@ -31,16 +31,17 @@ impl ConsoleExt {
     }
 
     /// Print function that prints the first argument to the console.
-    fn internal_print(
+    fn internal_print<'gc>(
         agent: &mut Agent,
         _this: Value,
         args: ArgumentsList,
-        mut gc: GcScope<'_, '_>,
-    ) -> JsResult<Value> {
+        mut gc: GcScope<'gc, '_>,
+    ) -> JsResult<'gc, Value<'gc>> {
         stdout()
             .write_all(
                 args[0]
-                    .to_string(agent, gc.reborrow())?
+                    .to_string(agent, gc.reborrow())
+                    .unbind()?
                     .as_str(agent)
                     .as_bytes(),
             )
@@ -50,69 +51,67 @@ impl ConsoleExt {
     }
 
     /// Exit the process with the given exit code.
-    pub fn internal_exit(
+    pub fn internal_exit<'gc>(
         agent: &mut Agent,
         _this: Value,
         args: ArgumentsList,
-        mut gc: GcScope<'_, '_>,
-    ) -> JsResult<Value> {
-        std::process::exit(args[0].to_int32(agent, gc.reborrow())?);
+        mut gc: GcScope<'gc, '_>,
+    ) -> JsResult<'gc, Value<'gc>> {
+        std::process::exit(args[0].to_int32(agent, gc.reborrow()).unbind()?);
     }
 
     /// Internal read for reading from the console.
-    pub fn internal_read(
+    pub fn internal_read<'gc>(
         agent: &mut Agent,
         _this: Value,
         _args: ArgumentsList,
-        gc: GcScope<'_, '_>,
-    ) -> JsResult<Value> {
+        gc: GcScope<'gc, '_>,
+    ) -> JsResult<'gc, Value<'gc>> {
         let mut input = String::new();
         std::io::stdin().read_line(&mut input).unwrap();
-        Ok(Value::from_string(
-            agent,
-            input.trim_end().to_string(),
-            gc.nogc(),
-        ))
+        Ok(Value::from_string(agent, input.trim_end().to_string(), gc.nogc()).unbind())
     }
 
     /// Internal read line for reading from the console with a newline.
-    pub fn internal_read_line(
+    pub fn internal_read_line<'gc>(
         agent: &mut Agent,
         _this: Value,
         _args: ArgumentsList,
-        gc: GcScope<'_, '_>,
-    ) -> JsResult<Value> {
+        gc: GcScope<'gc, '_>,
+    ) -> JsResult<'gc, Value<'gc>> {
         let mut input = String::new();
         std::io::stdin().read_line(&mut input).unwrap();
-        Ok(Value::from_string(
-            agent,
-            input.trim_end().to_string(),
-            gc.nogc(),
-        ))
+        Ok(Value::from_string(agent, input.trim_end().to_string(), gc.nogc()).unbind())
     }
 
     /// Internal write for writing to the console.
-    pub fn internal_write(
+    pub fn internal_write<'gc>(
         agent: &mut Agent,
         _this: Value,
         args: ArgumentsList,
-        mut gc: GcScope<'_, '_>,
-    ) -> JsResult<Value> {
+        mut gc: GcScope<'gc, '_>,
+    ) -> JsResult<'gc, Value<'gc>> {
         for arg in args.iter() {
-            print!("{}", arg.to_string(agent, gc.reborrow())?.as_str(agent));
+            print!(
+                "{}",
+                arg.to_string(agent, gc.reborrow()).unbind()?.as_str(agent)
+            );
         }
         Ok(Value::Undefined)
     }
 
     /// Internal write line for writing to the console with a newline.
-    pub fn internal_write_line(
+    pub fn internal_write_line<'gc>(
         agent: &mut Agent,
         _this: Value,
         args: ArgumentsList,
-        mut gc: GcScope<'_, '_>,
-    ) -> JsResult<Value> {
+        mut gc: GcScope<'gc, '_>,
+    ) -> JsResult<'gc, Value<'gc>> {
         for arg in args.iter() {
-            print!("{}", arg.to_string(agent, gc.reborrow())?.as_str(agent));
+            print!(
+                "{}",
+                arg.to_string(agent, gc.reborrow()).unbind()?.as_str(agent)
+            );
         }
         println!();
         Ok(Value::Undefined)