Promise.all and Promise.allSettled infer incorrect types from Array subclasses

[asnaeb]

lib Update Request

Configuration Check

My compilation target is ES2020 and my lib is the default.

Missing / Incorrect Definition

Promise.all
Promise.allSettled

Sample Code

declare class ArrayChild<T> extends Array<T> {}

declare const array: Array<Promise<number>>
declare const child: ArrayChild<Promise<number>>

Promise.all(array).then(a => a /* number[] */) 
Promise.allSettled(array).then(a => a /* PromiseSettledResult<number>[] */)

Promise.all(child).then(a => a /* {[K in keyof ArrayChild]: number} */) 
Promise.allSettled(child).then(a => /* {[K in keyof ArrayChild]: PromiseSettledResult<number>} */) 

Playground link

Documentation Link

Promise.all
Promise.allSettled

Possible fix

The inferred value should be of type number[] exactly like what happens with normal Array class. In the linked playground, It can be seen that Promise.all and Promise.allSettled infer the correct type with an Iterable type of object. This undesired behavior just happens with Array subclasses. I have quickly tried changing the signature from the original:

allSettled<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>> }>;
all<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]> }>;

to

allSettled<T extends Promise<unknown>[]>(values: T): Promise<T extends Promise<infer S>[] ? PromiseSettledResult<S>[] : never>
all<T extends Promise<unknown>[]>(values: T): Promise<T extends Promise<infer S>[] ? S[] : never>

and it works as expected: Playground link

[IllusionMH]

This would break tuples, which (I assume), are more common use case than Array subclasses in promise methods.

Example

[andrewbranch]

Yeah, we definitely can’t break tuple inference here. Seems like there could be another way to write it, but we’ll have to weigh the complexity and performance cost against how useful it actually is on average in real code.

[asnaeb]

Extending Array class, while uncommon is part of the language and this bug can be a wall against libraries development, for example. I'm going to spend some time in finding a solution as soon as I get the chance!

[asnaeb]

While I didn't test this exhaustively, It looks like it's working

declare function all<T extends [unknown] | ArrayLike<unknown> | Iterable<unknown>>(values: T): Promise<
    T extends {[P in 0]: unknown} ? 
        {-readonly [P in keyof T]: Awaited<T[P]>} : 
            T extends ArrayLike<infer S> | Iterable<infer S> ? Awaited<S>[] : never 
>

Playground Link