Support overload resolution with type union arguments

TypeScript Version: 2.1.6

Code

interface Foo {
    bar(s: string): void;
    bar(n: number): number;
    bar(b: boolean): boolean;
}
type SN = string | number;

var sn1: string | number;
var sn2: SN;
var foo: Foo;

var x1 = foo.bar(sn1); // error
var x2 = foo.bar(sn2); // error

Expected behavior: This should be allowed. The type of x1 and x2 should be void | number, the union of the matching overload return types.

All 3 overloads can be seen as a single overload with a union type. It should try to fallback to a union when it can’t match one of the originally defined overloads.

Actual behavior: error TS2345: Argument of type ‘string | number’ is not assignable to parameter of type ‘boolean’. Type ‘string’ is not assignable to type ‘boolean’.

[DanielRosenwasser]

I can’t find other issues where this discussion’s been had, but I’ll try to give some context. The single-parameter case always tends to be the most frustrating one for people, and the most obvious one to fix. The problem occurs when you have multiple overloads.

For example, suppose you had the following overloads

interface Foo {
    bar(s1: string, s2: string): void;
    bar(n1: number, n2: number): number;
}

and you tried calling with the following:

declare var sn1: string | number;
declare var sn2: string | number;
declare var foo: Foo

foo(sn1, sn2);

Should our call to foo succeed? Probably not, since we can’t guarantee that sn1 and sn2 share the same type.

So we could come up with a way of trying to collapse overloads that differ by exactly one parameter into unions and retying the overload process, but I think our concerns are

1. It seems a little ad-hoc, and ideally we’d like to generalize the behavior.
2. That process could be expensive (although this is less of a concern - this could be lazily done if overload resolution fails).
3. This process is potentially not as trivial as it sounds at face value.

[burtek]

Just out of curiosity: what’s the status of this issue? 🤔