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.

Commencez par reproduire l’exemple de TypeScript Playground et comparez le comportement entre les versions signalées. Étudiez l’inférence et le rétrécissement des types fondés sur le flux de contrôle pour un let typé implicitement et assigné depuis MyType ; le travail est considéré comme terminé lorsque la branche else finale est rétrécie de manière cohérente ou produit le diagnostic convenu sans perturber le rétrécissement précédent.