Implement Promise.all

[komyg]

No description provided.

[aapoalas]

Great job so far! The heap addition looks really good, though some parts are missing.

[aapoalas]

thought: Here it might be more appropriate to use the ElementsVector type, though that is not quite so easy with its API as the Array is.

Hmmm, ElementsVector should maybe be renamed to List...

[aapoalas]

suggestion: I've actually started to move us away from using the Index traits, as they leak the Output type to the public scope when both the "key" (PromiseAllRecord) and the "target" (Agent) are public.

A set of get and get_mut methods on PromiseAllRecord (taking either Agent or AsRef/AsMut<[PromiseAllRecordHeapData]>, depending on your taste and needs) is what I've been doing recently, although that should really be turned into a custom trait.

[aapoalas]

issue: Here you seem to be missing the loop over the marked PromiseAllRecords; see below all the drain things.

Also, there's an is_empty method that should check for && promise_all_records.is_empty().

[aapoalas]

nitpick: Combine imports.

[aapoalas]

issue: Aight, let's move this method to PromiseAllRecord; it doesn't really need to change all that much. Assuming we set up the get and get_mut method on PromiseAllRecord then something like this ought to do:

pub(crate) fn on_promise_fufilled(
        self,
        agent: &mut Agent,
        index: u32,
        value: Value<'a>,
        mut gc: GcScope<'a, '_>,
    ) {
        let promise_all = self.bind(gc.nogc());
        let value = value.bind(gc.nogc());
        let data = promise_all.get_mut(&mut agent.heap.promise_all_records); // splitting heap borrow
        let result_array = data.result_array.bind(gc.nogc()); // note: this copies the handle from the heap to stack; on stack we must always bind to make sure we don't use the handle after GC.
        let elements = result_array.as_mut_slice(...arrayheap...); // we want to split the heap borrow so we can get the elements slice as mutable at the same time as we get data as mutable. ArrayHeap is the thing you want to pass here here, IIRC.
        elements[index as usize] = Some(value.unbind());

        data.remaining_unresolved_promise_count -= 1;
        if data.remaining_unresolved_promise_count == 0 {
          let capability = ...;
          capability.resolve(agent, result_array.into_value().unbind(), gc);
        }
}

Now everything should be up-and-up from the GC perspective.

[aapoalas]

nitpick: No need to reborrow "on the last line" so to say; though here it doesn't have any effect really.

[aapoalas]

note: I'm skipping reviewing the all method; it's missing nearly all spec text and I assume it's still mostly WIP and testing code for you.

[komyg]

Yes, this is mostly WIP and debug code at this point. I will mark it more clearly next time.