fix

Author: aapoalas

nova_cli/src/main.rs

@@ -15,7 +15,7 @@ use nova_vm::ecmascript::{
         Agent,
     },
     scripts_and_modules::script::{parse_script, script_evaluation},
-    types::{Object, Value},
+    types::Object,
 };
 use oxc_parser::Parser;
 use oxc_semantic::{SemanticBuilder, SemanticBuilderReturn};
@@ -113,7 +113,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
             verbose,
             no_strict,
             nogc,
-            paths
+            paths,
         } => {
             let allocator = Default::default();
 
@@ -143,10 +143,11 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                 agent.run_in_realm(&realm, |agent| -> Result<(), Box<dyn std::error::Error>> {
                     let realm = agent.current_realm_id();
                     let file = std::fs::read_to_string(&path)?;
-                    let script = match parse_script(&allocator, file.into(), realm, !no_strict, None) {
-                        Ok(script) => script,
-                        Err((file, errors)) => exit_with_parse_errors(errors, &path, &file),
-                    };
+                    let script =
+                        match parse_script(&allocator, file.into(), realm, !no_strict, None) {
+                            Ok(script) => script,
+                            Err((file, errors)) => exit_with_parse_errors(errors, &path, &file),
+                        };
                     let mut result = script_evaluation(agent, script);
 
                     if result.is_ok() {
@@ -180,24 +181,20 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
         Command::Repl {} => {
             let allocator = Default::default();
             let host_hooks: &CliHostHooks = &*Box::leak(Box::default());
-            let mut agent = Agent::new(
+            let mut agent = GcAgent::new(
                 Options {
                     disable_gc: false,
                     print_internals: true,
                 },
                 host_hooks,
             );
-            {
-                let create_global_object: Option<fn(&mut Realm) -> Object> = None;
-                let create_global_this_value: Option<fn(&mut Realm) -> Object> = None;
-                initialize_host_defined_realm(
-                    &mut agent,
-                    create_global_object,
-                    create_global_this_value,
-                    Some(initialize_global_object),
-                );
-            }
-            let realm = agent.current_realm_id();
+            let create_global_object: Option<fn(&mut Agent) -> Object> = None;
+            let create_global_this_value: Option<fn(&mut Agent) -> Object> = None;
+            let realm = agent.create_realm(
+                create_global_object,
+                create_global_this_value,
+                Some(initialize_global_object),
+            );
 
             set_theme(DefaultTheme);
             println!("\n\n");
@@ -209,26 +206,37 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
 
                 if input.matches("exit").count() == 1 {
                     std::process::exit(0);
+                } else if input.matches("gc").count() == 1 {
+                    agent.gc();
+                    continue;
                 }
                 placeholder = input.to_string();
-                let script = match parse_script(&allocator, input.into(), realm, true, None) {
-                    Ok(script) => script,
-                    Err((file, errors)) => {
-                        exit_with_parse_errors(errors, "<stdin>", &file);
-                    }
-                };
-                let result = script_evaluation(&mut agent, script);
-                match result {
-                    Ok(result) => {
-                        println!("{:?}\n", result);
-                    }
-                    Err(error) => {
-                        eprintln!(
-                            "Uncaught exception: {}",
-                            error.value().string_repr(&mut agent).as_str(&agent)
-                        );
+                agent.run_in_realm(&realm, |agent| {
+                    let script = match parse_script(
+                        &allocator,
+                        input.into(),
+                        agent.current_realm_id(),
+                        true,
+                        None,
+                    ) {
+                        Ok(script) => script,
+                        Err((file, errors)) => {
+                            exit_with_parse_errors(errors, "<stdin>", &file);
+                        }
+                    };
+                    let result = script_evaluation(agent, script);
+                    match result {
+                        Ok(result) => {
+                            println!("{:?}\n", result);
+                        }
+                        Err(error) => {
+                            eprintln!(
+                                "Uncaught exception: {}",
+                                error.value().string_repr(agent).as_str(agent)
+                            );
+                        }
                     }
-                }
+                });
             }
         }
     }

nova_vm/tests/garbage_collection_tests.rs

@@ -78,8 +78,14 @@ fn garbage_collection_tests() {
     );
     agent.run_in_realm(&realm, |agent| {
         let realm = agent.current_realm_id();
-        let script =
-            parse_script(&allocator, header_contents.into_boxed_str(), realm, None).unwrap();
+        let script = parse_script(
+            &allocator,
+            header_contents.into_boxed_str(),
+            realm,
+            false,
+            None,
+        )
+        .unwrap();
         let _ = script_evaluation(agent, script).unwrap_or_else(|err| {
             panic!(
                 "Header evaluation failed: '{}' failed: {:?}",
@@ -97,6 +103,7 @@ fn garbage_collection_tests() {
                 &allocator,
                 call_contents.clone().into_boxed_str(),
                 realm,
+                false,
                 None,
             )
             .unwrap();

nova_vm/tests/object_prototype_tests.rs

@@ -30,7 +30,8 @@ fn object_prototype_tests() {
     let realm = agent.create_default_realm();
     agent.run_in_realm(&realm, |agent| {
         let realm = agent.current_realm_id();
-        let script = parse_script(&allocator, contents.into_boxed_str(), realm, false, None).unwrap();
+        let script =
+            parse_script(&allocator, contents.into_boxed_str(), realm, false, None).unwrap();
         let _ = script_evaluation(agent, script).unwrap_or_else(|err| {
             panic!(
                 "Test '{}' failed: {:?}",