Added promise all settled constructor

Author: komyg

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

@@ -24,6 +24,7 @@ use crate::{
             promise_objects::{
                 promise_abstract_operations::{
                     promise_all_record::PromiseAllRecord,
+                    promise_all_settled_record::PromiseAllSettledRecord,
                     promise_capability_records::if_abrupt_reject_promise_m,
                     promise_reaction_records::PromiseReactionHandler,
                 },
@@ -350,11 +351,115 @@ impl PromiseConstructor {
     /// > constructor.
     fn all_settled<'gc>(
         agent: &mut Agent,
-        _this_value: Value,
-        _arguments: ArgumentsList,
-        gc: GcScope<'gc, '_>,
+        this_value: Value,
+        arguments: ArgumentsList,
+        mut gc: GcScope<'gc, '_>,
     ) -> JsResult<'gc, Value<'gc>> {
-        Err(agent.todo("Promise.allSettled", gc.into_nogc()))
+        let this_value = this_value.bind(gc.nogc());
+        let arguments = arguments.bind(gc.nogc());
+        let iterable = arguments.get(0).scope(agent, gc.nogc());
+
+        // 1. Let C be the this value.
+        if this_value
+            != agent
+                .current_realm_record()
+                .intrinsics()
+                .promise()
+                .into_value()
+        {
+            return Err(throw_promise_subclassing_not_supported(
+                agent,
+                gc.into_nogc(),
+            ));
+        }
+
+        // 2. Let promiseCapability be ? NewPromiseCapability(C).
+        let Some(constructor) = is_constructor(agent, this_value) else {
+            return Err(agent.throw_exception_with_static_message(
+                ExceptionType::TypeError,
+                "Expected the this value to be a constructor.",
+                gc.into_nogc(),
+            ));
+        };
+        let constructor = constructor.scope(agent, gc.nogc());
+        let promise_capability = PromiseCapability::new(agent, gc.nogc());
+        let promise = promise_capability.promise().scope(agent, gc.nogc());
+
+        // 3. Let promiseResolve be Completion(GetPromiseResolve(C)).
+        let promise_resolve = get_promise_resolve(agent, constructor.get(agent), gc.reborrow())
+            .unbind()
+            .bind(gc.nogc());
+
+        // 4. IfAbruptRejectPromise(promiseResolve, promiseCapability).
+        let promise_capability = PromiseCapability {
+            promise: promise.get(agent).bind(gc.nogc()),
+            must_be_unresolved: true,
+        };
+        let promise_resolve =
+            if_abrupt_reject_promise_m!(agent, promise_resolve, promise_capability, gc);
+        let promise_resolve = promise_resolve.scope(agent, gc.nogc());
+
+        // 5. Let iteratorRecord be Completion(GetIterator(iterable, sync)).
+        let iterator_record = get_iterator(agent, iterable.get(agent), false, gc.reborrow())
+            .unbind()
+            .bind(gc.nogc());
+
+        // 6. IfAbruptRejectPromise(iteratorRecord, promiseCapability).
+        let promise_capability = PromiseCapability {
+            promise: promise.get(agent).bind(gc.nogc()),
+            must_be_unresolved: true,
+        };
+        let MaybeInvalidIteratorRecord {
+            iterator,
+            next_method,
+        } = if_abrupt_reject_promise_m!(agent, iterator_record, promise_capability, gc);
+
+        let iterator = iterator.scope(agent, gc.nogc());
+
+        // 7. Let result be Completion(PerformPromiseAll(iteratorRecord, C, promiseCapability, promiseResolve)).
+        let mut iterator_done = false;
+        let result = perform_promise_all_settled(
+            agent,
+            iterator.clone(),
+            next_method.unbind(),
+            constructor,
+            promise_capability.unbind(),
+            promise_resolve,
+            &mut iterator_done,
+            gc.reborrow(),
+        )
+        .unbind()
+        .bind(gc.nogc());
+
+        // 8. If result is an abrupt completion, then
+        let result = match result {
+            Err(mut result) => {
+                // a. If iteratorRecord.[[Done]] is false, set result to Completion(IteratorClose(iteratorRecord, result)).
+                if !iterator_done {
+                    result = iterator_close_with_error(
+                        agent,
+                        iterator.get(agent),
+                        result.unbind(),
+                        gc.reborrow(),
+                    )
+                    .unbind()
+                    .bind(gc.nogc());
+                }
+
+                // b. IfAbruptRejectPromise(result, promiseCapability).
+                let promise_capability = PromiseCapability {
+                    promise: promise.get(agent).bind(gc.nogc()),
+                    must_be_unresolved: true,
+                };
+                // a. Perform ? Call(capability.[[Reject]], undefined, « value.[[Value]] »).
+                promise_capability.reject(agent, result.value().unbind(), gc.nogc());
+                // b. Return capability.[[Promise]].
+                promise_capability.promise()
+            }
+            Ok(result) => result,
+        };
+        // 9. Return ! result.
+        Ok(result.into_value().unbind())
     }
 
     /// ### [27.2.4.3 Promise.any ( iterable )](https://tc39.es/ecma262/#sec-promise.any)
@@ -801,6 +906,150 @@ fn perform_promise_all<'gc>(
     }
 }
 
+/// ### [27.2.4.2.1 PerformPromiseAllSettled ( iteratorRecord, constructor, resultCapability, promiseResolve )](https://tc39.es/ecma262/#sec-performpromiseallsettled)
+#[allow(clippy::too_many_arguments)]
+fn perform_promise_all_settled<'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,
+    mut gc: GcScope<'gc, '_>,
+) -> JsResult<'gc, Promise<'gc>> {
+    let result_capability = result_capability.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_settled_reference = agent
+        .heap
+        .create(PromiseAllSettledRecord {
+            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_settled_reference.get(agent).bind(gc.nogc());
+            let data = promise_all.get_mut(agent);
+            // i. Set remainingElementsCount.[[Value]] to remainingElementsCount.[[Value]] - 1.
+            data.remaining_elements_count -= 1;
+            // ii. If remainingElementsCount.[[Value]] = 0, then
+            if data.remaining_elements_count == 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 promise_all_settled = promise_all_settled_reference.get(agent).bind(gc.nogc());
+        let reaction = PromiseReactionHandler::PromiseAllSettled {
+            index,
+            promise_all_settled,
+        };
+        // k. Set onFulfilled.[[Capability]] to resultCapability.
+        // l. Set onFulfilled.[[RemainingElements]] to remainingElementsCount.
+        // m. Set remainingElementsCount.[[Value]] to remainingElementsCount.[[Value]] + 1.
+        promise_all_settled.get_mut(agent).remaining_elements_count += 1;
+        // 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, '_>,