feat(gc): Value lifetime

CONTRIBUTING.md

@@ -321,7 +321,7 @@ this is not a trivial piece of work. Right now a function in the engine might
 look like this:
 
 ```rs
-fn call(agent: &mut Agent, obj: Value, mut gc: Gc) -> JsResult<Value> {
+fn call<'gc>(agent: &mut Agent, obj: Value, mut gc: GcScope<'gc, '_>) -> JsResult<Value<'gc>> {
     if !obj.is_object() {
         return Err(agent.throw_error(agent, "Not object", gc));
     }
@@ -411,7 +411,7 @@ But what about when we call some mutable function and need to keep a reference
 to a stack value past that call? This is how that would look:
 
 ```rs
-fn call(agent: &mut Agent, value: Value, mut gc: Gc) -> JsResult<Value> {
+fn call<'gc>(agent: &mut Agent, value: Value, mut gc: GcScope<'gc, '_>) -> JsResult<Value<'gc>> {
     let value = unsafe { value.bind(agent) };
     let kept_value: Global<Value<'static>> = value.make_global(value);
     other_call(agent, gc.reborrow(), value.into_register())?;

nova_cli/src/helper.rs

@@ -1,18 +1,30 @@
-use nova_vm::ecmascript::{
-    builtins::{create_builtin_function, ArgumentsList, Behaviour, BuiltinFunctionArgs},
-    execution::{agent::ExceptionType, Agent, JsResult},
-    types::{
-        InternalMethods, IntoValue, Object, OrdinaryObject, PropertyDescriptor, PropertyKey,
-        String, Value,
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use nova_vm::{
+    ecmascript::{
+        builtins::{create_builtin_function, ArgumentsList, Behaviour, BuiltinFunctionArgs},
+        execution::{agent::ExceptionType, Agent, JsResult},
+        types::{
+            InternalMethods, IntoValue, Object, OrdinaryObject, PropertyDescriptor, PropertyKey,
+            String, Value,
+        },
     },
+    engine::context::{Bindable, GcScope},
 };
-use nova_vm::engine::context::GcScope;
 use oxc_diagnostics::OxcDiagnostic;
 
 /// Initialize the global object with the built-in functions.
 pub fn initialize_global_object(agent: &mut Agent, global: Object, mut gc: GcScope) {
+    let global = global.scope(agent, gc.nogc());
     // `print` function
-    fn print(agent: &mut Agent, _this: Value, args: ArgumentsList, gc: GcScope) -> JsResult<Value> {
+    fn print<'gc>(
+        agent: &mut Agent,
+        _this: Value,
+        args: ArgumentsList,
+        gc: GcScope<'gc, '_>,
+    ) -> JsResult<Value<'gc>> {
         if args.len() == 0 {
             println!();
         } else {
@@ -22,12 +34,12 @@ pub fn initialize_global_object(agent: &mut Agent, global: Object, mut gc: GcSco
     }
 
     // 'readTextFile' function
-    fn read_text_file(
+    fn read_text_file<'gc>(
         agent: &mut Agent,
         _: Value,
         args: ArgumentsList,
-        gc: GcScope,
-    ) -> JsResult<Value> {
+        gc: GcScope<'gc, '_>,
+    ) -> JsResult<Value<'gc>> {
         if args.len() != 1 {
             return Err(agent.throw_exception_with_static_message(
                 ExceptionType::Error,
@@ -45,7 +57,7 @@ pub fn initialize_global_object(agent: &mut Agent, global: Object, mut gc: GcSco
 
         let file = std::fs::read_to_string(path.as_str(agent))
             .map_err(|e| agent.throw_exception(ExceptionType::Error, e.to_string(), gc.nogc()))?;
-        Ok(String::from_string(agent, file, gc.nogc()).into_value())
+        Ok(String::from_string(agent, file, gc.into_nogc()).into_value())
     }
 
     let function = create_builtin_function(
@@ -56,11 +68,12 @@ pub fn initialize_global_object(agent: &mut Agent, global: Object, mut gc: GcSco
     );
     let property_key = PropertyKey::from_static_str(agent, "print", gc.nogc()).unbind();
     global
+        .get(agent)
         .internal_define_own_property(
             agent,
             property_key,
             PropertyDescriptor {
-                value: Some(function.into_value()),
+                value: Some(function.into_value().unbind()),
                 writable: Some(true),
                 enumerable: Some(false),
                 configurable: Some(true),
@@ -78,11 +91,12 @@ pub fn initialize_global_object(agent: &mut Agent, global: Object, mut gc: GcSco
     );
     let property_key = PropertyKey::from_static_str(agent, "readTextFile", gc.nogc()).unbind();
     global
+        .get(agent)
         .internal_define_own_property(
             agent,
             property_key,
             PropertyDescriptor {
-                value: Some(function.into_value()),
+                value: Some(function.into_value().unbind()),
                 writable: Some(true),
                 enumerable: Some(false),
                 configurable: Some(true),
@@ -95,12 +109,12 @@ pub fn initialize_global_object(agent: &mut Agent, global: Object, mut gc: GcSco
 
 pub fn initialize_global_object_with_internals(agent: &mut Agent, global: Object, mut gc: GcScope) {
     // `detachArrayBuffer` function
-    fn detach_array_buffer(
+    fn detach_array_buffer<'gc>(
         agent: &mut Agent,
         _this: Value,
         args: ArgumentsList,
-        gc: GcScope,
-    ) -> JsResult<Value> {
+        gc: GcScope<'gc, '_>,
+    ) -> JsResult<Value<'gc>> {
         let Value::ArrayBuffer(array_buffer) = args.get(0) else {
             return Err(agent.throw_exception_with_static_message(
                 ExceptionType::Error,
@@ -112,12 +126,12 @@ pub fn initialize_global_object_with_internals(agent: &mut Agent, global: Object
         Ok(Value::Undefined)
     }
 
-    fn create_realm(
+    fn create_realm<'gc>(
         agent: &mut Agent,
         _this: Value,
         _args: ArgumentsList,
-        _gc: GcScope,
-    ) -> JsResult<Value> {
+        _gc: GcScope<'gc, '_>,
+    ) -> JsResult<Value<'gc>> {
         let create_global_object: Option<for<'a> fn(&mut Agent, GcScope<'a, '_>) -> Object<'a>> =
             None;
         let create_global_this_value: Option<
@@ -128,7 +142,7 @@ pub fn initialize_global_object_with_internals(agent: &mut Agent, global: Object
             create_global_this_value,
             Some(initialize_global_object_with_internals),
         );
-        Ok(realm.global_object(agent).into_value())
+        Ok(realm.global_object(agent).into_value().unbind())
     }
 
     initialize_global_object(agent, global, gc.reborrow());
@@ -163,7 +177,7 @@ pub fn initialize_global_object_with_internals(agent: &mut Agent, global: Object
             agent,
             property_key,
             PropertyDescriptor {
-                value: Some(function.into_value()),
+                value: Some(function.into_value().unbind()),
                 writable: Some(true),
                 enumerable: Some(false),
                 configurable: Some(true),
@@ -186,7 +200,7 @@ pub fn initialize_global_object_with_internals(agent: &mut Agent, global: Object
             agent,
             property_key,
             PropertyDescriptor {
-                value: Some(function.into_value()),
+                value: Some(function.into_value().unbind()),
                 writable: Some(true),
                 enumerable: Some(false),
                 configurable: Some(true),

nova_cli/src/main.rs

@@ -15,12 +15,12 @@ use nova_vm::{
     ecmascript::{
         execution::{
             agent::{GcAgent, HostHooks, Job, Options},
-            Agent,
+            Agent, JsResult,
         },
         scripts_and_modules::script::{parse_script, script_evaluation},
-        types::{Object, String as JsString},
+        types::{Object, String as JsString, Value},
     },
-    engine::context::GcScope,
+    engine::context::{Bindable, GcScope},
 };
 use oxc_parser::Parser;
 use oxc_semantic::{SemanticBuilder, SemanticBuilderReturn};
@@ -90,6 +90,10 @@ impl Debug for CliHostHooks {
 }
 
 impl CliHostHooks {
+    fn has_promise_jobs(&self) -> bool {
+        !self.promise_job_queue.borrow().is_empty()
+    }
+
     fn pop_promise_job(&self) -> Option<Job> {
         self.promise_job_queue.borrow_mut().pop_front()
     }
@@ -186,17 +190,34 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                                 exit_with_parse_errors(errors, &path, source_text)
                             }
                         };
-                        let mut result = script_evaluation(agent, script, gc.reborrow());
+                        let result = script_evaluation(agent, script, gc.reborrow());
 
-                        if result.is_ok() {
-                            while let Some(job) = host_hooks.pop_promise_job() {
-                                if let Err(err) = job.run(agent, gc.reborrow()) {
-                                    result = Err(err);
-                                    break;
+                        fn run_microtask_queue<'gc>(
+                            agent: &mut Agent,
+                            host_hooks: &CliHostHooks,
+                            result: JsResult<Value>,
+                            mut gc: GcScope<'gc, '_>,
+                        ) -> JsResult<Value<'gc>> {
+                            match result.bind(gc.nogc()) {
+                                Ok(result) => {
+                                    let ok_result = result.unbind().scope(agent, gc.nogc());
+                                    while let Some(job) = host_hooks.pop_promise_job() {
+                                        job.run(agent, gc.reborrow())?;
+                                    }
+                                    Ok(ok_result.get(agent).bind(gc.into_nogc()))
                                 }
+                                Err(_) => result.bind(gc.into_nogc()),
                             }
                         }
 
+                        let result = if host_hooks.has_promise_jobs() {
+                            run_microtask_queue(agent, host_hooks, result.unbind(), gc.reborrow())
+                                .unbind()
+                                .bind(gc.nogc())
+                        } else {
+                            result
+                        };
+
                         match result {
                             Ok(result) => {
                                 if verbose {