Inferred type in generic function is too specific with strictNullChecks

[e98cuenc]

TypeScript Version: 2.5.2

Code

function ifnull<T>(x: T | null | undefined, def: T): T
{
	return x != null ? x : def;
}

ifnull(2, 1);

Expected behavior:

The inferred type for T should not depend on strictNullChecks.

Actual behavior:

It is number when used without strictNullChecks, but it is the type 1 when used with strictNullChecks.

I understand you don't want to infer the intersection type 1 | 2, but I think it will be more useful to infer the type number. Many generic functions accept two arguments of the same type (two numbers, two strings, etc.), but when you call it with different values Typescript (with strictNullChecks) will always issue an error because it will infer the incompatible types value1 and value2 for T.

Looks like this has to do with unions in general:

declare function f<T>(x: T | string, y: T): T;
f(2, 1); // fails

In strictNullChecks mode, the type T | null | undefined is a union, but without strictNullChecks it's just T.

[mhegazy]

A naked type variable has a higher inference priority than one that is not. so in the example @Andy-MS shared, inference of y's position has a higher property than that from x's position.
the result is that the inferences from the naked-type-parameter position gets picked, and that does not satisfy the overload.

This is specific to functions that return a naked type parameter, since the literal inferences will be used.

[typescript-bot]

Automatically closing this issue for housekeeping purposes. The issue labels indicate that it is unactionable at the moment or has already been addressed.