rebase woes

Author: aapoalas

nova_cli/src/main.rs

@@ -7,8 +7,8 @@ use std::{cell::RefCell, collections::VecDeque, fmt::Debug};
 use clap::{Parser as ClapParser, Subcommand};
 use nova_vm::ecmascript::{
     execution::{
-        agent::{GcAgent, Options},
-        initialize_host_defined_realm, Agent, DefaultHostHooks, Realm,
+        agent::{GcAgent, HostHooks, Job, Options},
+        initialize_host_defined_realm, Agent, Realm,
     },
     scripts_and_modules::script::{parse_script, script_evaluation},
     types::{Object, Value},
@@ -121,11 +121,11 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                             Ok(script) => script,
                             Err((file, errors)) => exit_with_parse_errors(errors, &path, &file),
                         };
-                        let result = script_evaluation(agent, script);
+                        let mut result = script_evaluation(agent, script);
 
                         if result.is_ok() {
                             while let Some(job) = host_hooks.pop_promise_job() {
-                                if let Err(err) = job.run(&mut agent) {
+                                if let Err(err) = job.run(agent) {
                                     result = Err(err);
                                     break;
                                 }

nova_vm/src/ecmascript/builtins/data_view.rs

@@ -122,16 +122,6 @@ impl InternalSlots for DataView {
 
 impl InternalMethods for DataView {}
 
-impl HeapMarkAndSweep for DataView {
-    fn mark_values(&self, queues: &mut crate::heap::WorkQueues) {
-        queues.data_views.push(*self);
-    }
-
-    fn sweep_values(&mut self, _compactions: &crate::heap::CompactionLists) {
-        todo!()
-    }
-}
-
 impl CreateHeapData<DataViewHeapData, DataView> for Heap {
     fn create(&mut self, data: DataViewHeapData) -> DataView {
         self.data_views.push(Some(data));

nova_vm/src/ecmascript/builtins/finalization_registry.rs

@@ -131,16 +131,6 @@ impl IndexMut<FinalizationRegistry> for Vec<Option<FinalizationRegistryHeapData>
     }
 }
 
-impl HeapMarkAndSweep for FinalizationRegistry {
-    fn mark_values(&self, queues: &mut crate::heap::WorkQueues) {
-        queues.finalization_registrys.push(*self);
-    }
-
-    fn sweep_values(&mut self, _compactions: &crate::heap::CompactionLists) {
-        todo!()
-    }
-}
-
 impl CreateHeapData<FinalizationRegistryHeapData, FinalizationRegistry> for Heap {
     fn create(&mut self, data: FinalizationRegistryHeapData) -> FinalizationRegistry {
         self.finalization_registrys.push(Some(data));

nova_vm/src/ecmascript/builtins/promise/data.rs

@@ -94,27 +94,47 @@ impl HeapMarkAndSweep for PromiseReactions {
 impl HeapMarkAndSweep for PromiseHeapData {
     fn mark_values(&self, queues: &mut WorkQueues) {
         self.object_index.mark_values(queues);
-        match self.promise_state {
+        self.promise_state.mark_values(queues);
+    }
+
+    fn sweep_values(&mut self, compactions: &CompactionLists) {
+        self.object_index.sweep_values(compactions);
+        self.promise_state.sweep_values(compactions);
+    }
+}
+
+impl HeapMarkAndSweep for PromiseState {
+    fn mark_values(&self, queues: &mut WorkQueues) {
+        match self {
+            PromiseState::Pending {
+                fulfill_reactions,
+                reject_reactions,
+                ..
+            } => {
+                fulfill_reactions.mark_values(queues);
+                reject_reactions.mark_values(queues);
+            }
             PromiseState::Fulfilled { promise_result }
             | PromiseState::Rejected { promise_result, .. } => {
                 promise_result.mark_values(queues);
             }
-            _ => {}
         }
-        self.promise_fulfill_reactions.mark_values(queues);
-        self.promise_reject_reactions.mark_values(queues);
     }
 
     fn sweep_values(&mut self, compactions: &CompactionLists) {
-        self.object_index.sweep_values(compactions);
-        match &mut self.promise_state {
+        match self {
+            PromiseState::Pending {
+                fulfill_reactions,
+                reject_reactions,
+                ..
+            } => {
+                fulfill_reactions.sweep_values(compactions);
+                reject_reactions.sweep_values(compactions);
+            }
             PromiseState::Fulfilled { promise_result }
-            | PromiseState::Rejected { promise_result } => {
+            | PromiseState::Rejected { promise_result, .. } => {
                 promise_result.sweep_values(compactions);
             }
-            _ => {}
         }
-        self.promise_fulfill_reactions.sweep_values(compactions);
-        self.promise_reject_reactions.sweep_values(compactions);
     }
 }

nova_vm/src/ecmascript/builtins/proxy.rs

@@ -229,16 +229,6 @@ impl IndexMut<Proxy> for Vec<Option<ProxyHeapData>> {
     }
 }
 
-impl HeapMarkAndSweep for Proxy {
-    fn mark_values(&self, queues: &mut crate::heap::WorkQueues) {
-        queues.proxys.push(*self);
-    }
-
-    fn sweep_values(&mut self, _compactions: &crate::heap::CompactionLists) {
-        todo!()
-    }
-}
-
 impl CreateHeapData<ProxyHeapData, Proxy> for Heap {
     fn create(&mut self, data: ProxyHeapData) -> Proxy {
         self.proxys.push(Some(data));

nova_vm/src/ecmascript/builtins/typed_array.rs

@@ -194,16 +194,6 @@ impl InternalSlots for TypedArray {
 
 impl InternalMethods for TypedArray {}
 
-impl HeapMarkAndSweep for TypedArrayIndex {
-    fn mark_values(&self, queues: &mut crate::heap::WorkQueues) {
-        queues.typed_arrays.push(*self);
-    }
-
-    fn sweep_values(&mut self, _compactions: &crate::heap::CompactionLists) {
-        todo!()
-    }
-}
-
 impl CreateHeapData<TypedArrayHeapData, TypedArray> for Heap {
     fn create(&mut self, data: TypedArrayHeapData) -> TypedArray {
         self.typed_arrays.push(Some(data));

nova_vm/src/ecmascript/builtins/weak_map.rs

@@ -133,16 +133,6 @@ impl IndexMut<WeakMap> for Vec<Option<WeakMapHeapData>> {
     }
 }
 
-impl HeapMarkAndSweep for WeakMap {
-    fn mark_values(&self, queues: &mut crate::heap::WorkQueues) {
-        queues.weak_maps.push(*self);
-    }
-
-    fn sweep_values(&mut self, _compactions: &crate::heap::CompactionLists) {
-        todo!()
-    }
-}
-
 impl CreateHeapData<WeakMapHeapData, WeakMap> for Heap {
     fn create(&mut self, data: WeakMapHeapData) -> WeakMap {
         self.weak_maps.push(Some(data));

nova_vm/src/ecmascript/builtins/weak_ref.rs

@@ -132,16 +132,6 @@ impl IndexMut<WeakRef> for Vec<Option<WeakRefHeapData>> {
     }
 }
 
-impl HeapMarkAndSweep for WeakRef {
-    fn mark_values(&self, queues: &mut crate::heap::WorkQueues) {
-        queues.weak_refs.push(*self);
-    }
-
-    fn sweep_values(&mut self, _compactions: &crate::heap::CompactionLists) {
-        todo!()
-    }
-}
-
 impl CreateHeapData<WeakRefHeapData, WeakRef> for Heap {
     fn create(&mut self, data: WeakRefHeapData) -> WeakRef {
         self.weak_refs.push(Some(data));

nova_vm/src/ecmascript/builtins/weak_set.rs

@@ -143,16 +143,6 @@ impl IndexMut<WeakSet> for Vec<Option<WeakSetHeapData>> {
     }
 }
 
-impl HeapMarkAndSweep for WeakSet {
-    fn mark_values(&self, queues: &mut crate::heap::WorkQueues) {
-        queues.weak_sets.push(*self);
-    }
-
-    fn sweep_values(&mut self, _compactions: &crate::heap::CompactionLists) {
-        todo!()
-    }
-}
-
 impl CreateHeapData<WeakSetHeapData, WeakSet> for Heap {
     fn create(&mut self, data: WeakSetHeapData) -> WeakSet {
         self.weak_sets.push(Some(data));