feat(ecmascript): Implement Promise.all (#797)

Co-authored-by: Aapo Alasuutari <[email protected]>

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_record;
 pub mod promise_capability_records;
 pub(crate) mod promise_finally_functions;
 pub(crate) mod promise_jobs;

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

@@ -0,0 +1,184 @@
+// 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 crate::{
+    ecmascript::{
+        builtins::{
+            Array, promise::Promise,
+            promise_objects::promise_abstract_operations::promise_capability_records::PromiseCapability,
+        },
+        execution::Agent,
+        types::{IntoValue, Value},
+    },
+    engine::{
+        context::{Bindable, GcScope, NoGcScope, bindable_handle},
+        rootable::{HeapRootData, HeapRootRef, Rootable},
+    },
+    heap::{
+        CompactionLists, CreateHeapData, Heap, HeapMarkAndSweep, WorkQueues, indexes::BaseIndex,
+    },
+};
+
+#[derive(Debug, Clone, Copy)]
+pub struct PromiseAllRecord<'a> {
+    pub(crate) remaining_elements_count: u32,
+    pub(crate) result_array: Array<'a>,
+    pub(crate) promise: Promise<'a>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+#[repr(transparent)]
+pub struct PromiseAll<'a>(BaseIndex<'a, PromiseAllRecord<'static>>);
+
+impl<'a> PromiseAll<'a> {
+    pub(crate) fn on_promise_fulfilled(
+        self,
+        agent: &mut Agent,
+        index: u32,
+        value: Value<'a>,
+        gc: GcScope<'a, '_>,
+    ) {
+        let promise_all = self.bind(gc.nogc());
+        let value = value.bind(gc.nogc());
+
+        let result_array = promise_all.get_result_array(agent, gc.nogc());
+
+        let elements = result_array.as_mut_slice(agent);
+        elements[index as usize] = Some(value.unbind());
+
+        let data = promise_all.get_mut(agent);
+
+        // i. Set remainingElementsCount.[[Value]] to remainingElementsCount.[[Value]] - 1.
+        data.remaining_elements_count = data.remaining_elements_count.saturating_sub(1);
+
+        //ii. If remainingElementsCount.[[Value]] = 0, then
+        if data.remaining_elements_count == 0 {
+            // 1. Let valuesArray be CreateArrayFromList(values).
+            // 2. Perform ? Call(resultCapability.[[Resolve]], undefined, « valuesArray »).
+            let capability = PromiseCapability::from_promise(data.promise, true);
+            capability.resolve(agent, result_array.into_value().unbind(), gc);
+        }
+    }
+
+    pub(crate) fn on_promise_rejected(
+        self,
+        agent: &mut Agent,
+        value: Value<'a>,
+        gc: NoGcScope<'a, '_>,
+    ) {
+        let value = value.bind(gc);
+        let promise_all = self.bind(gc);
+        let data = promise_all.get_mut(agent);
+
+        let capability = PromiseCapability::from_promise(data.promise, true);
+        capability.reject(agent, value.unbind(), gc);
+    }
+
+    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 AsRef<[PromiseAllRecord<'static>]> for Agent {
+    fn as_ref(&self) -> &[PromiseAllRecord<'static>] {
+        &self.heap.promise_all_records
+    }
+}
+
+impl AsMut<[PromiseAllRecord<'static>]> for Agent {
+    fn as_mut(&mut self) -> &mut [PromiseAllRecord<'static>] {
+        &mut self.heap.promise_all_records
+    }
+}
+
+impl HeapMarkAndSweep for PromiseAllRecord<'static> {
+    fn mark_values(&self, queues: &mut WorkQueues) {
+        let Self {
+            remaining_elements_count: _,
+            result_array,
+            promise,
+        } = self;
+        result_array.mark_values(queues);
+        promise.mark_values(queues);
+    }
+
+    fn sweep_values(&mut self, compactions: &CompactionLists) {
+        let Self {
+            remaining_elements_count: _,
+            result_array,
+            promise,
+        } = self;
+        result_array.sweep_values(compactions);
+        promise.sweep_values(compactions);
+    }
+}
+
+impl Rootable for PromiseAll<'_> {
+    type RootRepr = HeapRootRef;
+
+    fn to_root_repr(value: Self) -> Result<Self::RootRepr, HeapRootData> {
+        Err(HeapRootData::PromiseAll(value.unbind()))
+    }
+
+    fn from_root_repr(value: &Self::RootRepr) -> Result<Self, HeapRootRef> {
+        Err(*value)
+    }
+
+    fn from_heap_ref(heap_ref: HeapRootRef) -> Self::RootRepr {
+        heap_ref
+    }
+
+    fn from_heap_data(heap_data: HeapRootData) -> Option<Self> {
+        match heap_data {
+            HeapRootData::PromiseAll(object) => Some(object),
+            _ => None,
+        }
+    }
+}
+
+impl HeapMarkAndSweep for PromiseAll<'static> {
+    fn mark_values(&self, queues: &mut WorkQueues) {
+        queues.promise_all_records.push(*self);
+    }
+
+    fn sweep_values(&mut self, compactions: &CompactionLists) {
+        compactions.promise_all_records.shift_index(&mut self.0);
+    }
+}
+
+bindable_handle!(PromiseAllRecord);
+bindable_handle!(PromiseAll);
+
+impl<'a> CreateHeapData<PromiseAllRecord<'a>, PromiseAll<'a>> for Heap {
+    fn create(&mut self, data: PromiseAllRecord<'a>) -> PromiseAll<'a> {
+        self.promise_all_records.push(data.unbind());
+        self.alloc_counter += core::mem::size_of::<PromiseAllRecord<'static>>();
+        PromiseAll(BaseIndex::last_t(&self.promise_all_records))
+    }
+}

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

@@ -145,7 +145,7 @@ impl PromiseReactionJob {
         let Self { reaction, argument } = self;
         let reaction = reaction.take(agent).bind(gc.nogc());
         let argument = argument.take(agent).bind(gc.nogc());
-        // The following are substeps of point 1 in NewPromiseReactionJob.
+
         let (handler_result, promise_capability) = match agent[reaction].handler {
             PromiseReactionHandler::Empty => {
                 let capability = agent[reaction].capability.clone().unwrap().bind(gc.nogc());
@@ -278,15 +278,28 @@ impl PromiseReactionJob {
                         );
                         return Ok(());
                     }
+                    PromiseReactionType::Reject => (
+                        Err(JsError::new(argument)),
+                        PromiseCapability::from_promise(promise, true),
+                    ),
+                }
+            }
+            PromiseReactionHandler::PromiseAll { promise_all, index } => {
+                let reaction_type = agent[reaction].reaction_type;
+                match reaction_type {
+                    PromiseReactionType::Fulfill => {
+                        promise_all.on_promise_fulfilled(
+                            agent,
+                            index,
+                            argument.unbind(),
+                            gc.reborrow(),
+                        );
+                    }
                     PromiseReactionType::Reject => {
-                        // a. Perform ! Call(promiseCapability.[[Reject]], undefined, « reason »).
-                        // b. Return unused.
-                        (
-                            Err(JsError::new(argument)),
-                            PromiseCapability::from_promise(promise, true),
-                        )
+                        promise_all.on_promise_rejected(agent, argument.unbind(), gc.nogc());
                     }
                 }
+                return Ok(());
             }
         };
 
@@ -348,7 +361,8 @@ pub(crate) fn new_promise_reaction_job(
         | PromiseReactionHandler::AsyncFromSyncIteratorClose(_)
         | PromiseReactionHandler::AsyncModule(_)
         | PromiseReactionHandler::DynamicImport { .. }
-        | PromiseReactionHandler::DynamicImportEvaluate { .. } => None,
+        | PromiseReactionHandler::DynamicImportEvaluate { .. }
+        | PromiseReactionHandler::PromiseAll { .. } => None,
     };
 
     // 4. Return the Record { [[Job]]: job, [[Realm]]: handlerRealm }.

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

@@ -10,6 +10,7 @@ use crate::{
             async_generator_objects::AsyncGenerator,
             control_abstraction_objects::async_function_objects::await_reaction::AwaitReaction,
             promise::Promise,
+            promise_objects::promise_abstract_operations::promise_all_record::PromiseAll,
         },
         execution::Agent,
         scripts_and_modules::module::module_semantics::{
@@ -68,8 +69,13 @@ pub(crate) enum PromiseReactionHandler<'a> {
         promise: Promise<'a>,
         module: AbstractModule<'a>,
     },
+    PromiseAll {
+        index: u32,
+        promise_all: PromiseAll<'a>,
+    },
     Empty,
 }
+bindable_handle!(PromiseReactionHandler);
 
 impl HeapMarkAndSweep for PromiseReactionHandler<'static> {
     fn mark_values(&self, queues: &mut WorkQueues) {
@@ -85,6 +91,10 @@ impl HeapMarkAndSweep for PromiseReactionHandler<'static> {
                 promise.mark_values(queues);
                 module.mark_values(queues);
             }
+            Self::PromiseAll {
+                index: _,
+                promise_all,
+            } => promise_all.mark_values(queues),
             Self::Empty => {}
         }
     }
@@ -104,6 +114,12 @@ impl HeapMarkAndSweep for PromiseReactionHandler<'static> {
                 promise.sweep_values(compactions);
                 module.sweep_values(compactions);
             }
+            Self::PromiseAll {
+                index: _,
+                promise_all,
+            } => {
+                promise_all.sweep_values(compactions);
+            }
             Self::Empty => {}
         }
     }