WIP Peform trait

Author: komyg

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

@@ -2,6 +2,7 @@
 // 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/.
 
+pub(crate) mod promise_all;
 pub(crate) mod promise_all_record;
 pub(crate) mod promise_all_settled_record;
 pub mod promise_capability_records;

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

@@ -0,0 +1,36 @@
+use crate::{
+    ecmascript::{
+        builtins::{
+            Array,
+            promise_objects::promise_abstract_operations::promise_reaction_records::PromiseReactionHandler,
+        },
+        execution::Agent,
+        types::Value,
+    },
+    engine::{
+        context::{Bindable, GcScope, NoGcScope, bindable_handle},
+        rootable::Rootable,
+    },
+};
+
+pub(crate) trait PromiseAllReactionHandler<'a>: Rootable + Bindable {
+    fn get_result_array(self, agent: &Agent, gc: NoGcScope<'a, '_>) -> Array<'a>;
+    fn increase_remaining_elements_count(self, agent: &mut Agent, gc: NoGcScope<'a, '_>);
+    fn decrease_remaining_elements_count(self, agent: &mut Agent, gc: NoGcScope<'a, '_>);
+    fn get_remaining_elements_count(self, agent: &Agent, gc: NoGcScope<'a, '_>) -> u32;
+    fn on_promise_fulfilled(
+        self,
+        agent: &mut Agent,
+        index: u32,
+        value: Value<'a>,
+        gc: GcScope<'a, '_>,
+    );
+    fn on_promise_rejected(
+        self,
+        agent: &mut Agent,
+        index: u32,
+        value: Value<'a>,
+        gc: GcScope<'a, '_>,
+    );
+    fn to_reaction_handler(self, index: u32, gc: NoGcScope<'a, '_>) -> PromiseReactionHandler<'a>;
+}

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

@@ -5,8 +5,13 @@
 use crate::{
     ecmascript::{
         builtins::{
-            Array, promise::Promise,
-            promise_objects::promise_abstract_operations::promise_capability_records::PromiseCapability,
+            Array,
+            promise::Promise,
+            promise_objects::promise_abstract_operations::{
+                promise_all::PromiseAllReactionHandler,
+                promise_capability_records::PromiseCapability,
+                promise_reaction_records::PromiseReactionHandler,
+            },
         },
         execution::Agent,
         types::{IntoValue, Value},
@@ -32,7 +37,38 @@ pub struct PromiseAllRecord<'a> {
 pub struct PromiseAll<'a>(BaseIndex<'a, PromiseAllRecord<'static>>);
 
 impl<'a> PromiseAll<'a> {
-    pub(crate) fn on_promise_fulfilled(
+    // pub(crate) fn get_result_array(self, agent: &Agent, gc: NoGcScope<'a, '_>) -> Array<'a> {
+    //     let data = self.get(agent);
+    //     data.result_array.bind(gc).unbind()
+    // }
+
+    pub(crate) const fn get_index(self) -> usize {
+        self.0.into_index()
+    }
+
+    pub fn get(self, agent: &Agent) -> &PromiseAllRecord<'a> {
+        agent
+            .heap
+            .promise_all_records
+            .get(self.get_index())
+            .expect("PromiseAllRecord not found")
+    }
+
+    pub fn get_mut(self, agent: &mut Agent) -> &mut PromiseAllRecord<'static> {
+        agent
+            .heap
+            .promise_all_records
+            .get_mut(self.get_index())
+            .expect("PromiseAllRecord not found")
+    }
+
+    pub(crate) const fn _def() -> Self {
+        Self(BaseIndex::from_u32_index(0))
+    }
+}
+
+impl<'a> PromiseAllReactionHandler<'a> for PromiseAll<'a> {
+    fn on_promise_fulfilled(
         self,
         agent: &mut Agent,
         index: u32,
@@ -61,47 +97,49 @@ impl<'a> PromiseAll<'a> {
         }
     }
 
-    pub(crate) fn on_promise_rejected(
+    fn on_promise_rejected(
         self,
         agent: &mut Agent,
+        _index: u32,
         value: Value<'a>,
-        gc: NoGcScope<'a, '_>,
+        gc: GcScope<'a, '_>,
     ) {
-        let value = value.bind(gc);
-        let promise_all = self.bind(gc);
+        let value = value.bind(gc.nogc());
+        let promise_all = self.bind(gc.nogc());
         let data = promise_all.get_mut(agent);
 
         let capability = PromiseCapability::from_promise(data.promise, true);
-        capability.reject(agent, value.unbind(), gc);
+        capability.reject(agent, value.unbind(), gc.nogc());
     }
 
-    pub(crate) fn get_result_array(self, agent: &Agent, gc: NoGcScope<'a, '_>) -> Array<'a> {
+    fn get_result_array(self, agent: &Agent, gc: NoGcScope<'a, '_>) -> Array<'a> {
         let data = self.get(agent);
         data.result_array.bind(gc).unbind()
     }
 
-    pub(crate) const fn get_index(self) -> usize {
-        self.0.into_index()
+    fn increase_remaining_elements_count(self, agent: &mut Agent, gc: NoGcScope<'a, '_>) {
+        let promise_all = self.bind(gc);
+        let data = promise_all.get_mut(agent);
+        data.remaining_elements_count = data.remaining_elements_count.saturating_add(1);
     }
 
-    pub fn get(self, agent: &Agent) -> &PromiseAllRecord<'a> {
-        agent
-            .heap
-            .promise_all_records
-            .get(self.get_index())
-            .expect("PromiseAllRecord not found")
+    fn decrease_remaining_elements_count(self, agent: &mut Agent, gc: NoGcScope<'a, '_>) {
+        let promise_all = self.bind(gc);
+        let data = promise_all.get_mut(agent);
+        data.remaining_elements_count = data.remaining_elements_count.saturating_sub(1);
     }
 
-    pub fn get_mut(self, agent: &mut Agent) -> &mut PromiseAllRecord<'static> {
-        agent
-            .heap
-            .promise_all_records
-            .get_mut(self.get_index())
-            .expect("PromiseAllRecord not found")
+    fn get_remaining_elements_count(self, agent: &Agent, gc: NoGcScope<'a, '_>) -> u32 {
+        let promise_all = self.bind(gc);
+        promise_all.get(agent).remaining_elements_count
     }
 
-    pub(crate) const fn _def() -> Self {
-        Self(BaseIndex::from_u32_index(0))
+    fn to_reaction_handler(self, index: u32, gc: NoGcScope<'a, '_>) -> PromiseReactionHandler<'a> {
+        let promise_all = self.bind(gc);
+        PromiseReactionHandler::PromiseAll {
+            index,
+            promise_all: promise_all.unbind(),
+        }
     }
 }
 

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

@@ -12,7 +12,10 @@ use crate::{
             },
             operations_on_objects::{call_function, get_function_realm},
         },
-        builtins::{ArgumentsList, promise::Promise},
+        builtins::{
+            ArgumentsList, promise::Promise,
+            promise_objects::promise_abstract_operations::promise_all::PromiseAllReactionHandler,
+        },
         execution::{
             Agent, JsResult,
             agent::{InnerJob, Job, JsError},
@@ -296,7 +299,12 @@ impl PromiseReactionJob {
                         );
                     }
                     PromiseReactionType::Reject => {
-                        promise_all.on_promise_rejected(agent, argument.unbind(), gc.nogc());
+                        promise_all.on_promise_rejected(
+                            agent,
+                            index,
+                            argument.unbind(),
+                            gc.reborrow(),
+                        );
                     }
                 }
                 return Ok(());

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

@@ -23,6 +23,7 @@ use crate::{
             },
             promise_objects::{
                 promise_abstract_operations::{
+                    promise_all::{PromiseAllReactionHandler, PromiseType},
                     promise_all_record::PromiseAllRecord,
                     promise_all_settled_record::PromiseAllSettledRecord,
                     promise_capability_records::if_abrupt_reject_promise_m,
@@ -1058,6 +1059,149 @@ fn perform_promise_all_settled<'gc>(
     }
 }
 
+#[allow(clippy::too_many_arguments)]
+fn perform_promise_all_or_all_settled<'gc, T: PromiseAllReactionHandler<'gc>>(
+    agent: &mut Agent,
+    iterator: Scoped<Object>,
+    next_method: Option<Function>,
+    constructor: Scoped<Function>,
+    result_capability: PromiseCapability,
+    promise_resolve: Scoped<Function>,
+    iterator_done: &mut bool,
+    promise_all_handler: T,
+    mut gc: GcScope<'gc, '_>,
+) -> JsResult<'gc, Promise<'gc>> {
+    let result_capability = result_capability.bind(gc.nogc());
+    let promise_all_handler = promise_all_handler.bind(gc.nogc());
+
+    let Some(next_method) = next_method else {
+        return Err(throw_not_callable(agent, gc.into_nogc()));
+    };
+
+    let next_method = next_method.scope(agent, gc.nogc());
+
+    // 1. Let values be a new empty List.
+    let capacity = match iterator.get(agent) {
+        Object::Array(array) => array.len(agent),
+        Object::Map(map) => agent[map].size(),
+        Object::Set(set) => agent[set].size(),
+        _ => 0,
+    };
+
+    let result_array = array_create(agent, 0, capacity as usize, None, gc.nogc())
+        .unbind()?
+        .bind(gc.nogc());
+    let result_array = result_array.scope(agent, gc.nogc());
+
+    // 2. Let remainingElementsCount be the Record { [[Value]]: 1 }.
+    let promise = result_capability.promise.scope(agent, gc.nogc());
+    // let promise_all_reference = agent
+    //     .heap
+    //     .create(PromiseAllRecord {
+    //         remaining_elements_count: 1,
+    //         result_array: result_array.get(agent),
+    //         promise: promise.get(agent),
+    //     })
+    //     .scope(agent, gc.nogc());
+
+    // 3. Let index be 0.
+    let mut index = 0;
+
+    // 4. Repeat,
+    loop {
+        let iterator_record = IteratorRecord {
+            iterator: iterator.get(agent),
+            next_method: next_method.get(agent),
+        }
+        .bind(gc.nogc());
+
+        // a. Let next be ? IteratorStepValue(iteratorRecord).
+        let next = iterator_step_value(agent, iterator_record.unbind(), gc.reborrow())
+            .unbind()?
+            .bind(gc.nogc());
+
+        // b. If next is done, then
+        let Some(next) = next else {
+            *iterator_done = true;
+            // let promise_all = promise_all_reference.get(agent).bind(gc.nogc());
+            // i. Set remainingElementsCount.[[Value]] to remainingElementsCount.[[Value]] - 1.
+            promise_all_handler.decrease_remaining_elements_count(agent, gc.nogc());
+            // ii. If remainingElementsCount.[[Value]] = 0, then
+            if promise_all_handler.get_remaining_elements_count(agent, gc.nogc()) == 0 {
+                // 1. Let valuesArray be CreateArrayFromList(values).
+                let values_array = result_array.get(agent).bind(gc.nogc());
+                // 2. Perform ? Call(resultCapability.[[Resolve]], undefined, « valuesArray »).
+                let result_capability = PromiseCapability {
+                    promise: promise.get(agent).bind(gc.nogc()),
+                    must_be_unresolved: true,
+                };
+                result_capability.unbind().resolve(
+                    agent,
+                    values_array.into_value().unbind(),
+                    gc.reborrow(),
+                );
+            }
+
+            // iii. Return resultCapability.[[Promise]].
+            return Ok(promise.get(agent));
+        };
+
+        // c. Append undefined to values.
+        let temp_array = result_array.get(agent).bind(gc.nogc());
+        if let Err(err) = temp_array.reserve(agent, 1) {
+            return Err(agent.throw_allocation_exception(err, gc.into_nogc()));
+        }
+        // SAFETY: reserve did not fail.
+        unsafe { temp_array.set_len(agent, index + 1) };
+
+        // d. Let nextPromise be ? Call(promiseResolve, constructor, « next »).
+        let call_result = call_function(
+            agent,
+            promise_resolve.get(agent),
+            constructor.get(agent).into_value(),
+            Some(ArgumentsList::from_mut_value(&mut next.unbind())),
+            gc.reborrow(),
+        )
+        .unbind()?
+        .bind(gc.nogc());
+
+        // Note: as we don't yet support Promise subclassing, if we see a
+        // non-Promise return we wrap it inside a resolved Promise to get
+        // then-chaining.
+        let next_promise = match call_result {
+            Value::Promise(next_promise) => next_promise,
+            _ => Promise::new_resolved(agent, call_result),
+        };
+
+        // e. Let steps be the algorithm steps defined in Promise.all Resolve Element Functions.
+        // f. Let length be the number of non-optional parameters of the function definition in Promise.all Resolve Element Functions.
+        // g. Let onFulfilled be CreateBuiltinFunction(steps, length, "", « [[AlreadyCalled]], [[Index]], [[Values]], [[Capability]], [[RemainingElements]] »).
+        // h. Set onFulfilled.[[AlreadyCalled]] to false.
+        // i. Set onFulfilled.[[Index]] to index.
+        // j. Set onFulfilled.[[Values]] to values.
+        let reaction = promise_all_handler
+            .to_reaction_handler(index, gc.nogc())
+            .bind(gc.nogc());
+
+        // k. Set onFulfilled.[[Capability]] to resultCapability.
+        // l. Set onFulfilled.[[RemainingElements]] to remainingElementsCount.
+        // m. Set remainingElementsCount.[[Value]] to remainingElementsCount.[[Value]] + 1.
+        promise_all_handler.increase_remaining_elements_count(agent, gc.nogc());
+        // n. Perform ? Invoke(nextPromise, "then", « onFulfilled, resultCapability.[[Reject]] »).
+        inner_promise_then(
+            agent,
+            next_promise.unbind(),
+            reaction.unbind(),
+            reaction.unbind(),
+            None,
+            gc.nogc(),
+        );
+
+        // o. Set index to index + 1.
+        index += 1;
+    }
+}
+
 fn throw_promise_subclassing_not_supported<'a>(
     agent: &mut Agent,
     gc: NoGcScope<'a, '_>,