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

Activity

1. aweebit

   changed the title [-]The expression `someBool || true` is of type `true` while the expression `true` is of type `boolean`[/-] [+]`someBool || true` gets the literal type `true` when assigned to a re-assignable variable (unlike `true` getting the type `boolean`)[/+] on Jun 1, 2025
2. aweebit

   changed the title [-]`someBool || true` gets the literal type `true` when assigned to a re-assignable variable (unlike `true` getting the type `boolean`)[/-] [+]`someBool || true` gets the literal type `true` when assigned to a `let` variable at initialization (unlike `true` getting the type `boolean`)[/+] on Jun 1, 2025
3. Andarist commented on Jun 2, 2025

   

   Mateusz Burzyński (Andarist)

   on Jun 2, 2025

   Contributor

   More actions

   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.

   👍React with 👍1Reacted by aweebit
4. Ryan Cavanaugh (RyanCavanaugh)

   added

   Not a DefectThis behavior is one of several equally-correct optionsThis behavior is one of several equally-correct options

   on Jun 3, 2025
5. RyanCavanaugh commented on Jun 3, 2025

   

   Ryan Cavanaugh (RyanCavanaugh)

   on Jun 3, 2025

   Member

   More actions

   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.
6. snarbles2 commented on Jun 3, 2025

   

   snarbles2

   on Jun 3, 2025

   More actions

   I don't necessarily think it warrants a change, but I think it's fair to characterize the inconsistent behavior as confusing or unexpected.
7. aweebit commented on Jun 3, 2025

   

   aweebit

   on Jun 3, 2025

   Author

   More actions

   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?
8. Andarist commented on Jun 3, 2025

   

   Mateusz Burzyński (Andarist)

   on Jun 3, 2025

   Contributor

   More actions

   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
9. typescript-bot commented on Jun 6, 2025

   

   TypeScript Bot (typescript-bot)

   on Jun 6, 2025

   Contributor

   More actions

   This issue has been marked as "Not a Defect" and has seen no recent activity. It has been automatically closed for house-keeping purposes.
10. TypeScript Bot (typescript-bot)

    closed this as not plannedon Jun 6, 2025
11. microsoft

    locked as resolved and limited conversation to collaborators on Oct 22, 2025