Unexpected union inference because of generic function argument

[gcnew]

TypeScript Version: nightly (2.4.0-dev.20170502)

TypeScript improperly infers a union type when a generic function is used as an argument. Such an inference is unexpected unless the union constituent is present, or the type arguments are manually provided by the programmer.

Code

declare function sameType<T>(x: T, y: T): T;
declare function test<R>(f: (x: string, y: number) => R): void;

test(sameType); // bad inference: R = string | number

[ahejlsberg]

I'm not sure I see why inferring a union type is incorrect. After all, there are no declared constraints on T and it is indeed possible to pass sameType to test with the inferred union type argument. I agree that in a general unification scenario (e.g. where sameType and test are both passed as arguments to a third function) we probably wouldn't want to infer a union, however in this particular case we know that we're inferring types for one in terms of the other (but not vice versa).

[gcnew]

Because by having a type argument, the expectation for it is to be resolved to a single type. I think I've read it somewhere in the docs that type inference doesn't create types and it doesn't infer unions unless they are provided by the programmer. If that were not the case, how would a type variable be constrained to a single type?

It seems counter intuitive to me for a function such as sameType, which states that x and y have the same type, to be circumvented by saying "they have the same synthetic union type". If I didn't need x and y to have the same type, I would have used different type variables.

PS: The current behaviour creates some discrepancies. E.g. a variation of the example from #138:

declare var f: <R>(s: string, n: number) => R;
declare var g: <T>(x: T, y: T) => T;
f = g; // good, error with #16368

declare function test1(h: typeof f): void;
declare function test2<R>(h: (s: string, n: number) => R): void;
test1(g); // good, error with #16368
test2(g); // no error? how is this different from test1

---

Edit: I've been wrong, test1 and test2 are substantially different. The expanded signature of test1 is

declare function test1(h: <R>(s: string, n: number) => R): void;

Here, the type parameter R is universally quantified, i.e. test1 accepts a function h, which should be able to return any possible type. When we pass in g as an argument, it will simply return its first argument, which is incorrect.

In test2 the type parameter R is existentially quantified in regards to h.

[gcnew]

I'm not sure I can give a more convincing example. Type variables are inferred to a single type in all locations except for function arguments. And even there it's not always the case as the code from my previous comment shows. I believe that generic inference behaviour should be uniform across all uses.

declare function test3<R>(x: R, y: R): void;
declare function test4<R>(h: (s: string, n: number) => R, x: R, y: R): void;

test3(3, 'str'); // good, error with #16368
test4(g, 3, 'str'); // no error :(, what's changed?