Refinement type inference quirk with implicitly typed `let x`

🔎 Search Terms

refinement narrow let any

🕗 Version & Regression Information

• This changed between versions 3.9.7 and 4.0.5; the behavior is present in every version from 4.0.5 to 5.3 nightly; I skimmed the whole FAQ document and didn't find anything relevant

⏯ Playground Link

https://www.typescriptlang.org/play?ts=5.3.0-dev.20231013#code/C4TwDgpgBAsiAq5oF4oG8qkgLigcgEE8oBfKAH3UyVzwCFiSBuAKBYDMBXAOwGNgAlgHtuUdgAoAhgCcA5rjiJIASnQsoGqABsIwKAA9Wmg1FQzZRzQPZRx+gHRYUyVITyq06zWQhaAztDWtg5Opi74DB5eGj7+0J7Gxjp6APq43BAAbhDSpgaWMSwkLEA

💻 Code

type MyType = { type: 'A' } | { type: 'B' };

function f(arg: MyType) {
    let x;
    x = arg;
    if (x.type === 'A') {
    } else if (x.type === 'B') {
    } else {
        let _: never = x;
    }
}

🙁 Actual behavior

error TS2322: Type '{ type: "B"; }' is not assignable to type 'never'.

9         let _: never = x;
              ~

This is wrong for two reasons:

• In the world of perfect type inference, x should be narrowed to never at this point
• Even acknowledging that there could be some practical limitations, the behavior is not consistent.
  
  First conditional successfully eliminates the "A" variant:
  
  But second conditional fails to eliminate the "B" variant:
  

🙂 Expected behavior

Ideally, this shouldn't be an error at all.

However, given that control-flow-based type inference has its limitations, perhaps some kind of spurious error is inevitable. In that case, it probably should be more like Type 'MyType' is not assignable to type 'never' rather than Type '{ type: "B" }' is not assignable to type 'never'.

Additional information about the issue

Practical impact of this issue is small. There is an easy workaround of adding an explicit type annotation (let x: MyType;).

However, this asymmetry, that the last conditional fails at narrowing when exactly the same conditional before that succeeds, bothers me. I'm reporting this because it could be a symptom of a more general implementation defect.

Beginne damit, das TypeScript Playground-Beispiel zu reproduzieren, und vergleiche das Verhalten zwischen den gemeldeten Versionen. Untersuche die auf dem Kontrollfluss basierende Typinferenz und -eingrenzung für ein implizit typisiertes let, das aus MyType zugewiesen wird; abgeschlossen ist die Untersuchung, wenn der abschließende else-Zweig konsistent eingegrenzt wird oder die vereinbarte Diagnose erzeugt, ohne die vorherige Eingrenzung zu beeinträchtigen.