Inference mismatch in strict and non-strict mode

[dipeshkaphle]

🔎 Search Terms

"type-inference", "bug", "boolean-literals"

🕗 Version & Regression Information

$ tsc --version
Version 5.9.3

⏯ Playground Link

https://www.typescriptlang.org/play/?#code/DYUwLgBAxgTg9gdwEYEMYGcIF4IAoJgwCuIEKmhJEAlAFC1RwB26kAjkSoSgJYvZ4CxUuQhI4cUCiY16oSAFs+PLkRikcuXLESoM1CAB9DeDlxi8W1OrQBmRJlDA9mY4HwDWuFBxBwi6ABcEKwwfADm1MEAtACsAGwQtADetBAQ8hAADgAWcGBwIAAmAvhxiaLlNADcadDMrBAAbiBOcBilELYowOgimOKSINI1dUpMKmBqGs2tBRi16epTMDLZeQXFtQC+tEA

💻 Code

let crowbars = ( true as true )

const quatrains = ( true as boolean )

let miniature = ((crowbars) || (quatrains))

function blink(aqueous: string): -56 
{
  let photoed = ( -56 as -56 );
  const vectors = ( false as boolean );
  miniature = vectors;
  return  photoed;
}

🙁 Actual behavior

The program fails to compile in strict mode, but compiles fine in non-strict mode.

🙂 Expected behavior

This program doesn't have anything that should be affected by turning on strict mode, so behaviour should be exactly the same.

Additional information about the issue

No response

[MartinJohns]

This is working as intended. With strictNullChecks disabled your variable crowbars may contain null or undefined, changing the logical-or check in miniature (it's no longer always the left expression) and as a result the inferred variable type is changed.

[dipeshkaphle]

Also, just noticed that when I change the code to have this:

let miniature = ((quatrains) || (crowbars))

(just swapped the order of these two variables)

With just this change, the program fails to typecheck in both strict and non-strict mode.

Is this reasonable?

crowbars may contain null or undefined

The LSP shows that its type is true though

[dipeshkaphle]

Original program without strict checks: Link

Swapped the variable order in the or and the program fails to compile again with the same flags: Link

[MartinJohns]

Is this reasonable?

Yes, it is, due to the reason I provided.

The LSP shows that its type is true though

With strictNullChecks disabled the type true can be one of three different values (two of them falsy), with the option enabled only one value is permitted.

[MartinJohns]

With strictNullChecks enabled:

• The type of crowbars is true, which only can contain the truthy value true.
• This means the logical-or check crowbars || quatrains will always short-circuit to the left expression, because the compiler knows it's always truthy.
• As a result the variable miniature gets the type true (because crowbars is typed true).
• In line 11 you get an error, because vectors is typed boolean, but you try to assign it to a variable typed true.

With strictNullChecks disabled:

• The variable crowbars typed true can contain three different values: true, undefined, null.
• Because now crowbars can be falsy the compiler can't short-circuit crowbars || quatrains anymore - it may now result in the right-side expression.
• As a result the variable miniature is typed boolean (not true), because the logical-or expression is typed true | boolean, which gets widened to boolean.
• Now the assignment in line 11 works, because boolean can be assigned to a variable typed boolean.

It's all working as expected and intended.

[dipeshkaphle]

Oh, alright, then. Just to confirm, this kind of behavior isn't demonstrated in any docs, right? I tried to find documentation around this behavior in strict mode, but couldn't.

Thanks for the clear explanation!

[MartinJohns]

It does mention it here: https://www.typescriptlang.org/docs/handbook/2/basic-types.html#strictnullchecks

By default, values like null and undefined are assignable to any other type.

The rest is just logical narrowing: https://www.typescriptlang.org/docs/handbook/2/narrowing.html#truthiness-narrowing