Regression: Rest parameter typed as union of tuple types behaves differently in 4.3

[dragomirtitian]

Bug Report

🔎 Search Terms

tuples rest parameter regression

🕗 Version & Regression Information

• This changed between versions 4.2 and 4.3-beta

⏯ Playground Link

Playground link with relevant code

💻 Code

class EventEmitter<ET> {
    // works with overloads
    // off<K extends keyof ET>(...args: [K, unknown]): void
    // off<K extends keyof ET>(...args: [K | unknown]): void
    off<K extends keyof ET>(...args: [K, unknown] | [K | unknown]):void {}

    
}
function once<ET, T extends EventEmitter<ET>>(
    emittingObject: T,
    eventName: keyof ET,
    callback: (event: unknown) => void,
): void {
    emittingObject.off(eventName, callback); /* fails*/
    
    // type assertion works as well
    emittingObject.off(eventName as keyof ET, callback);
    
}

🙁 Actual behavior

The call emittingObject.off(eventName, callback); fails with Argument of type '[string | number | symbol, (event: unknown) => void]' is not assignable to parameter of type '[unknown] | [keyof ET, unknown]'.

🙂 Expected behavior

The call should succeed as it did in 4.2

[RyanCavanaugh]

Trimming off the last little bit of fat:

class EventEmitter<ET> {
    off<K extends keyof ET>(...args: [K, number] | [unknown, string]):void {}
}
function once<ET, T extends EventEmitter<ET>>(emittingObject: T, eventName: keyof ET): void {
    // Fail
    emittingObject.off(eventName, 0);
    // Pass (?!)
    emittingObject.off(eventName as typeof eventName, 0);
}

It looks like something's gone wrong here where we construct a contextual type for argument position 0 (correct) and then decide to use the presence of that to devolve eventName from keyof ET to its constraint string | number | symbol (bad). But it's something specific to the tuple syntax, since equivalentish forms like off<K extends keyof ET>(args: K | boolean, a2: string | number):void {} don't trigger this.

[ahejlsberg]

This is caused by #43183. The issue is that the contextual type of the first argument to off is K | unknown, which ends up reducing to just unknown. Since unknown contains no generic types we think it is safe to reduce keyof ET to its constraint string | number | symbol which would be a candidate for narrowing by CFA. The fix is to ensure K | unknown doesn't get reduced. We do that elsewhere for contextual types, just not in the particular scenario of arguments to rest parameters with union types.

[dragomirtitian]

@DanielRosenwasser @RyanCavanaugh This does not appear fixed in 4.3.2 (Playground Link) but works in nightly (Playground Link). Will there be a 4.3.3 where this will be included ?