Does not infer discriminated unions with !==

[ChuckJonas]

TypeScript Version: v3.5.1

Search Terms:
discriminated unions, !==
Code

export interface K9 {
  variant: 'DOG' | 'WOLF';
  bark: ()=>void;
}

export interface Feline {
  variant: 'CAT' | 'LION';
  meow: ()=>void;
}

export type CatOrDog = K9 | Feline;

let instance = {} as any as (K9 | Feline)

if (instance.variant === 'DOG' || instance.variant === 'WOLF') {
    instance.bark(); //works
}

if (instance.variant !== 'DOG' && instance.variant !== 'WOLF') {
    let x = instance.variant; //correct type inferred
    instance.meow() //should work but doesn't
}

Expected behavior:

The first condition check should be able to infer that we are dealing with a Feline.

Actual behavior:
It is unable to discriminate.

Playground Link: playground link

Related Issues: #27541

[jack-williams]

What's the difference between this and #30557?

[RyanCavanaugh]

@jack-williams here, the narrowed identifier was declared as a union

[ahejlsberg]

It works if you change the declaration of K9 to

export interface Dog {
  variant: 'DOG';
  bark: ()=>void;
}

export interface Wolf {
  variant: 'WOLF';
  bark: ()=>void;
}

export type K9 = Dog | Wolf;

The reason it doesn't work as originally written is that when instance.variant !== 'DOG' is applied to the original declaration of K9, no narrowing is performed (because variant could still be 'WOLF'). Likewise, instance.variant !== 'WOLF' doesn't by itself narrow instance. However, when K9 is declared as a union type we can individually narrow.

So, it's working as intended, but you could argue it is a design limitation.