`someBool || true` gets the literal type `true` when assigned to a `let` variable at initialization (unlike `true` getting the type `boolean`)

[aweebit]

🔎 Search Terms

boolean literal type true false assign expression

🕗 Version & Regression Information

• This changed between versions 4.1.5 and 4.2.3
• Not sure but feat(40197): No "did you mean to call" error when invocation is part of a logical expression #40260 could be the reason

⏯ Playground Link

https://www.typescriptlang.org/play/?#code/CYUwxgNghgTiAEEQBd4GcD2BbEAhDGEAXPAEYFJQB2A3AFB1KogAeUWADkgIzwC88ZDACuIek3it2XEACZ+6bHgrwAPqsEixQA

💻 Code

declare let someBool: boolean;

let okay = true;
let weird = someBool || true;

🙁 Actual behavior

weird is assigned the type true, whereas okay is of type boolean.

🙂 Expected behavior

Both variables have the type boolean.

Additional information about the issue

Stumbled upon this while writing facebook/react#33399.

Very unexpected and confusing behavior, I highly doubt it is intended. Couldn't find anything explaining the change in the release notes for TypeScript 4.2, so pretty sure it's an unwanted regression. Please correct me if I'm wrong.

[Andarist]

I'm pretty sure this has changed in #42353 . checkBinaryExpressionWorker calls getUnionType here on the left and right type and after the change, it eliminates the fresh true type in favor of its regular type.

[RyanCavanaugh]

I don't really know what's confusing or unexpected about a value that we know has the value true having the type true. Absent a more principled reason to change this, let's not break something else in the process.

[snarbles2]

I don't necessarily think it warrants a change, but I think it's fair to characterize the inconsistent behavior as confusing or unexpected.

[aweebit]

I don't really know what's confusing or unexpected about a value that we know has the value true having the type true.

The confusing part is the fact that it's different from how an even simpler true expression results in a wider type in the end.

With let x = true it couldn't be more clear that the value will be true, yet the variable ends up having the boolean type assigned to it rather than true. That, of course, happens for a good reason. Why should someBool || true behave any different then?

[Andarist]

By the applied reasoning, this should be string | true but it's not:

declare const str: string
let example3 = str || true
//   ^? let example3: string | boolean

We could say though that the right operand is contextually-typed by the left one:

declare const maybeFn: ((arg: number) => void) | null;
let example4 = maybeFn || ((arg) => {});
//   ^? let example4: (arg: number) => void

But that principle doesn't fully apply to primitives (albeit maybe for some other reasons, widening behavior of strings/numbers was always confusing to me):

declare const maybeString: "" | null
let example5 = maybeString || ""
//   ^? let example5: string

It's also worth noting boolean has some history of being special-cased so it doesn't always get typed contextually, for example in #48380

[typescript-bot]

This issue has been marked as "Not a Defect" and has seen no recent activity. It has been automatically closed for house-keeping purposes.