Incorrect union type inference for conjunction with strictNullChecks disabled

[pedro-pedrosa]

TypeScript Version: 3.4.5

Search Terms: union type inference conjunction strictNullChecks

Code

function fn(x: number) {
  return x && 'a'
}

Expected behavior:
Return type of fn should be 0 | 'a'

Actual behavior:
Return type of fn is '' | 'a' if strictNullChecks is disabled

This is causing me an issue with this specific bit of code, where I'm checking window so my code runs both on the browser and on the client:

function fn(x: number): OrientationType | undefined {
  return window && (window.outerWidth > window.outerHeight ? 'landscape-primary' : 'portrait-primary')
}

I can replace the conjunction with a conditional expression, and I know that if strictNullChecks is disabled I should have a fallback for the return value but I'm posting here for the sake of trying to understand if this is working as intended. It also feels weird that my example compiles with strictNullChecks enabled but doesn't compile when it's disabled.

Playground Link: https://www.typescriptlang.org/play/#src=function%20fn(x%3A%20number)%3A%20OrientationType%20%7C%20undefined%20%7B%0D%0A%20%20return%20window%20%26%26%20(window.outerWidth%20%3E%20window.outerHeight%20%3F%20'landscape-primary'%20%3A%20'portrait-primary')%0D%0A%7D

Related Issues:

[fatcerberus]

It seems like TS is inferring the type of && based on the type of the thing on the RHS (which is a string), without regard to the type of x. Best I can tell it's typing the expression as though it was

return String(x) && 'a'

...which of course is wrong because && doesn't coerce its operands to make them match--unlike, say, ==.

This happens from the other direction too:

function fn(x: string) {
  return x && 812;
}

type FN = typeof fn;  // (x: string) => 0 | 812;

I'm not sure why strictNullChecks affects inference here - in theory its only effect should be to remove | undefined | null from the type; whether nullish values are allowed or not should be immaterial to how the operands of && are coerced (or not coerced, as the case may be).

[pedro-pedrosa]

Yes I noticed that, it's as if it's using the "falsy" value from the RHS.

Even more strange:

function fn(x: number) {
  return x && (x > 0 ? 'a' : 1);
}

typeof fn; // "" | 0 | "a" | 1

[RyanCavanaugh]

Moving to Dormant as strictNullChecks: false is increasingly rare (and hard to reason about)