Handle errors

Author: komyg

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

@@ -48,11 +48,25 @@ impl<'a> PromiseAll<'a> {
         data.remaining_unresolved_promise_count =
             data.remaining_unresolved_promise_count.saturating_sub(1);
         if data.remaining_unresolved_promise_count == 0 {
-            let capability = PromiseCapability::from_promise(data.promise, false);
+            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()

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

@@ -278,27 +278,32 @@ impl PromiseReactionJob {
                         );
                         return Ok(());
                     }
-                    PromiseReactionType::Reject => {
-                        // a. Perform ! Call(promiseCapability.[[Reject]], undefined, « reason »).
-                        // b. Return unused.
-                        (
-                            Err(JsError::new(argument)),
-                            PromiseCapability::from_promise(promise, true),
-                        )
-                    }
+                    PromiseReactionType::Reject => (
+                        Err(JsError::new(argument)),
+                        PromiseCapability::from_promise(promise, true),
+                    ),
                 }
             }
             PromiseReactionHandler::PromiseAll { promise_all, index } => {
                 let reaction_type = agent[reaction].reaction_type;
                 let capability = agent[reaction].capability.clone().unwrap();
+                let scoped_arg = argument.scope(agent, gc.nogc());
                 match reaction_type {
                     PromiseReactionType::Fulfill => {
-                        let arg_unbound = argument.unbind();
-                        promise_all.on_promise_fulfilled(agent, index, arg_unbound, gc.reborrow());
-                        (Ok(arg_unbound.bind(gc.nogc())), capability.bind(gc.nogc()))
+                        promise_all.on_promise_fulfilled(
+                            agent,
+                            index,
+                            scoped_arg.get(agent),
+                            gc.reborrow(),
+                        );
+                        (Ok(scoped_arg.get(agent)), capability.bind(gc.nogc()))
                     }
                     PromiseReactionType::Reject => {
-                        (Err(JsError::new(argument)), capability.bind(gc.nogc()))
+                        promise_all.on_promise_rejected(agent, scoped_arg.get(agent), gc.nogc());
+                        (
+                            Err(JsError::new(scoped_arg.get(agent))),
+                            capability.bind(gc.nogc()),
+                        )
                     }
                 }
             }

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

@@ -293,7 +293,10 @@ impl PromiseConstructor {
                     index,
                     promise_all: promise_all_record,
                 },
-                PromiseReactionHandler::Empty,
+                PromiseReactionHandler::PromiseAll {
+                    index,
+                    promise_all: promise_all_record,
+                },
                 Some(capability.unbind()),
                 gc.nogc(),
             );