Callback argument type not inferred for union of interfaces

[nwalters512]

🔎 Search Terms

"implicitly has an" inference

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about "inference"

⏯ Playground Link

https://www.typescriptlang.org/play/?target=5&ts=5.5.3#code/KYDwDg9gTgLgBASwHY2FAZgQwMbDgQQGcBPJbAJWEIFcAbGAYU1toCMcBrAHgBUAaOAFE4AXiFQo0AHxwA3gFgAUHBVwAFGigB+AFxC4AHzhI6tAVCp0YuuDwCUegG4QEAEwDcSgL5KloSLCIKGhYuAQkZJQ09ACSqFCYMNC8AuQCwmKCEtJySqrqCKgAtnr8cNjMbJx6RKQUlvRMLOzY3GlCUg5wzm6eij6K-tDwyPGheLWRDTBxaInQAAqSRQiEwClw5DIKyqpqhcAltl1LECtrXFt9A0quwNi0mBZw6NRkMAgQSHBFmGAAMggVjANu0MuJJFApGo8qonlBSgBtAC6fFhKloQMKehMRVYaDRuxUBwSSQRKkm9WiM3i8ygp3O6zKW0M4TqUSss1JyWZ6SkhJOy1W63IKKkfSUvwBWJgakRAEY+AAmPgAZlRcFVAkwEWw6iQdlE23RcAsMGoUG+3wAVNa4ErrnZ3EA

💻 Code

export interface AsyncResultCallback<T, E = Error> {
    (err?: E | null, result?: T): void;
}

export interface AsyncResultIterator<T, R, E = Error> {
    (item: T, callback: AsyncResultCallback<R, E>): void;
}
export interface AsyncResultIteratorPromise<T, R> {
    (item: T): Promise<R>;
}

declare function mapLimit<T, R, E = Error>(
    arr: T[],
    limit: number,
    iterator:  AsyncResultIteratorPromise<T, R> | AsyncResultIterator<T, R, E>,
): Promise<R[]>;

mapLimit([1,2,3], 3, async (n) => {
    return n ** 2;
});

🙁 Actual behavior

The type of n in the mapLimit callback is inferred as any:

Parameter 'n' implicitly has an 'any' type. (7006)

🙂 Expected behavior

I would expect the type of n to be inferred as number.

Additional information about the issue

This example is based on the types for the async package:

https://github.com/DefinitelyTyped/DefinitelyTyped/blob/b9820410f85f259cbad6065d8cb6f23f403109ac/types/async/index.d.ts#L321-L325

Note that if the type for iterator in mapLimit is changed to either just AsyncResultIteratorPromise<T, R> or just AsyncResultIterator<T, R, E> (that is, no longer a union type), things work as expected and n has type number.

I found a very old discussion of what looks to be the same issue in the DefinitelyTyped repo: DefinitelyTyped/DefinitelyTyped#24297. The issue described there is exactly the one I'm facing. One commenter claimed that things worked correctly, and another commenter claimed that changing the way that async was imported had some effect? Neither of those sounds plausible to me.

I found some issues that may describe the same or a similar problem:

• Contextual parameter types failed to be provided based on filtering mapped types #56881
• No type inferrence of callback arguments inside a tuple union type #55632
• Callback parameter inference not working when part of an inferred tuple type #52047
• Improve inference in the presence of context-sensitive expressions #47599

However, my knowledge of TypeScript internals/terminology isn't strong enough to say for sure that this isn't a novel issue I'm facing. If this is in fact a duplicate, please close it as such and I'll add this example to the relevant issue. Thank you!

[Andarist]

Simpler repro:

function test<T>(
  arr: T[],
  cb: ((item: T) => void) | ((item: T, extra: unknown) => void),
) {}

test([1, 2, 3], (item) => {});

Currently, getContextualSignature returns undefined in this situation because the 2 signatures that are present here don't pass the compareSignaturesIdentical check in that function