Fix warns

Author: komyg

nova_vm/src/ecmascript/builtins/control_abstraction_objects/promise_objects/promise_abstract_operations/promise_all_record.rs

@@ -11,7 +11,7 @@ use crate::{
             promise_objects::promise_abstract_operations::promise_capability_records::PromiseCapability,
         },
         execution::Agent,
-        types::Value,
+        types::{IntoValue, Value},
     },
     engine::context::{Bindable, GcScope, NoGcScope},
     heap::{
@@ -23,6 +23,7 @@ use crate::{
 pub struct PromiseAllRecordHeapData<'a> {
     pub remaining_unresolved_promise_count: u32,
     pub result_array: Array<'a>,
+    pub promise: Promise<'a>,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
@@ -35,12 +36,11 @@ impl<'a> PromiseAllRecordHeapData<'a> {
         agent: &mut Agent,
         index: u32,
         value: Value<'a>,
-        gc: NoGcScope<'a, '_>,
+        mut gc: GcScope<'a, '_>,
     ) {
-        eprintln!("Self memory address: {:p}", &self);
-        // Update the result array at the specified index by reconstructing it
+        value.bind(gc.nogc());
         let array_slice = self.result_array.as_slice(agent);
-        let new_values: Vec<Value> = array_slice
+        array_slice
             .iter()
             .enumerate()
             .map(|(i, opt_val)| {
@@ -50,26 +50,20 @@ impl<'a> PromiseAllRecordHeapData<'a> {
                     opt_val.unwrap_or(Value::Undefined) // Keep existing or default
                 }
             })
-            .collect();
+            .collect::<Vec<_>>();
 
-        eprintln!("Index: {:#?}", index);
-        eprintln!("New values: {:#?}", new_values);
-        eprintln!(
-            "Remaining unresolved promise count: {:#?}",
-            self.remaining_unresolved_promise_count
-        );
-
-        self.result_array = Array::from_slice(agent, &new_values, gc);
-        eprintln!("Result array memory address: {:p}", &self.result_array);
+        // Update in place to avoid consuming the GC scope
+        let elements = self.result_array.as_mut_slice(agent);
+        elements[index as usize] = Some(value.unbind());
 
         self.remaining_unresolved_promise_count -= 1;
         if self.remaining_unresolved_promise_count == 0 {
-            eprintln!(
-                "All promises fulfilled, should resolve main promise: {:#?}",
-                self.result_array
+            let capability = PromiseCapability::from_promise(self.promise, true);
+            capability.resolve(
+                agent,
+                self.result_array.unbind().into_value(),
+                gc.reborrow(),
             );
-            // self.promise_capability
-            //     .resolve(agent, self.result_array, gc.into_nogc());
         }
     }
 }

nova_vm/src/ecmascript/builtins/control_abstraction_objects/promise_objects/promise_abstract_operations/promise_jobs.rs

@@ -304,7 +304,12 @@ impl PromiseReactionJob {
 
                         // Bind to current scope and mutate
                         let mut rec_bound = rec.unbind().bind(gc.nogc());
-                        rec_bound.on_promise_fufilled(agent, index, argument.unbind(), gc.nogc());
+                        rec_bound.on_promise_fufilled(
+                            agent,
+                            index,
+                            argument.clone(),
+                            gc.reborrow(),
+                        );
 
                         // Write back with 'static lifetime
                         agent

nova_vm/src/ecmascript/builtins/control_abstraction_objects/promise_objects/promise_abstract_operations/promise_reaction_records.rs

@@ -7,7 +7,7 @@ use core::ops::{Index, IndexMut};
 use crate::{
     ecmascript::{
         builtins::{
-            Array, async_generator_objects::AsyncGenerator,
+            async_generator_objects::AsyncGenerator,
             control_abstraction_objects::async_function_objects::await_reaction::AwaitReaction,
             promise::Promise,
             promise_objects::promise_abstract_operations::promise_all_record::PromiseAllRecord,

nova_vm/src/ecmascript/builtins/control_abstraction_objects/promise_objects/promise_constructor.rs

@@ -2,12 +2,10 @@
 // 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 crate::ecmascript::abstract_operations::operations_on_objects::create_array_from_list;
-use crate::ecmascript::builtins::promise_objects::promise_abstract_operations::promise_all_record::{PromiseAllRecordHeapData, PromiseAllRecord};
+use crate::ecmascript::builtins::promise_objects::promise_abstract_operations::promise_all_record::PromiseAllRecordHeapData;
 use crate::ecmascript::builtins::promise_objects::promise_abstract_operations::promise_reaction_records::PromiseReactionHandler;
 use crate::ecmascript::builtins::promise_objects::promise_prototype::inner_promise_then;
-use crate::ecmascript::builtins::{create_builtin_function, Array, BuiltinFunctionArgs};
-use crate::ecmascript::fundamental_objects::function_objects::function_constructor::create_dynamic_function;
+use crate::ecmascript::builtins::Array;
 use crate::{
     ecmascript::{
         abstract_operations::{
@@ -287,9 +285,12 @@ impl PromiseConstructor {
         };
 
         let result_capability = PromiseCapability::new(agent, gc.nogc());
-
         let second_capability = PromiseCapability::new(agent, gc.nogc());
-        let result_promise = result_capability.promise();
+
+        let result_promise = PromiseCapability::new(agent, gc.nogc())
+            .promise()
+            .unbind()
+            .bind(gc.nogc());
 
         // let result_callback_closure: for<'a, 'b, 'c, 'd, 'e, '_gc> fn(
         //     &'a mut Agent,
@@ -329,6 +330,7 @@ impl PromiseConstructor {
         let promise_all_record = agent.heap.create(PromiseAllRecordHeapData {
             remaining_unresolved_promise_count: 2,
             result_array,
+            promise: result_promise,
         });
 
         inner_promise_then(