Revert perform trait creation

Author: komyg

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

@@ -2,7 +2,6 @@
 // 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

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

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

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

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

@@ -23,7 +23,6 @@ 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,
@@ -1059,149 +1058,6 @@ 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, '_>,