Switch doesn't narrow type when type isn't a disc union

[aryzing]

🔎 Search Terms

discriminated union, switch

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about switch

⏯ Playground Link

https://www.typescriptlang.org/play/?target=99#code/C4TwDgpgBAYg9nKBeKBvKBLAJgLigcgDMF8AaKLAQ2Er3wCNKAnfKAXwCgBjOAOwGdgUYnDzxEKdNjoiyFarQKMW7Dh34B3DMC4ALKAAoRAOmwBKNByhQulftCIk86HgLgAbCMfdwA5gfwAW2o9fAtOaywIQkoAV3dgPGBdJjgNKF4IdIBRJlSmAwAiADlEYJ1dQvIXOPs8ESh+agx+QgwIfgyIADcIJnYzDjYgA

💻 Code

type Foo = { id: 'foo', data: 'bar' }
const foo: Foo = { id: 'foo', data: 'bar' }

switch (foo.id) {
  case 'foo': { console.log('match') }
  default: throw new Error("No match", { cause: foo satisfies never })
//                                                  ^^^^^^^^^
}

🙁 Actual behavior

Despite expecting the value to be of type never, it retains its original type.

🙂 Expected behavior

The value in the default branch should be typed as never.

Additional information about the issue

No response

[MartinJohns]

Duplicate of #13182.

[RyanCavanaugh]

🤖 Thank you for your issue! I've done some analysis to help get you started. This response is automatically generated; feel free to 👍 or 👎 this comment according to its usefulness.

Possible Relevant FAQs

Exclude Isn't Type Negation

switch‐based narrowing only removes cases from a union. In the snippet

const foo: { id: 'foo'; data: 'bar' } = { id: 'foo', data: 'bar' };

switch (foo.id) {
  case 'foo':
    console.log('match');
    break;
  default:
    throw new Error('No match', { cause: foo satisfies never });
}

foo is not a union; it has the single, concrete type { id: 'foo'; data: 'bar' }. Because there is nothing to filter out, control‐flow analysis leaves foo unchanged in the default block. The situation is the same as Exclude<string, 'hello'> evaluating to string: when the input is not a union, no member gets excluded, so the original type is preserved.

To have the default branch inferred as never, the switched expression must come from a genuine union:

type Foo = { id: 'foo'; data: 'bar' };
type Bar = { id: 'bar'; data: number };

type Value = Foo | Bar;

declare const value: Value;

switch (value.id) {
  case 'foo':
    // value is Foo here
    break;
  case 'bar':
    // value is Bar here
    break;
  default:
    // value is never here – all union members were handled above
    const _exhaustive: never = value;
}

When every union member is covered by explicit case clauses, the default arm becomes unreachable and TypeScript assigns never to value. Without a union, there is nothing for the type system to eliminate, so the variable keeps its original type.

Similar Issues

Here are the most similar issues I found

• (80%) microsoft/typescript#59953: Switch typeguard for single case
• (77%) microsoft/typescript#33670: Inconsistency in narrowing behavior between non-union and union
• (77%) microsoft/typescript#16976: narrowing in switch doesn't work with non-union types
• (76%) microsoft/typescript#49334: Strange narrowing behavior on objects using discriminator property
• (74%) microsoft/typescript#24412: Degenerated Union Type
• (74%) microsoft/typescript#61207: Discriminated Union is not narrowed to never when all types are checked in default case if discriminator field is literal type
• (74%) microsoft/typescript#43056: Exhaustive check fails to narrow type when union has only 1 type
• (73%) microsoft/typescript#20375: narrowing in switches doesnt work on constrained unions
• (73%) microsoft/typescript#47288: Narrowing issue: exhaustive pattern matching on a "union" of only one type
• (73%) microsoft/typescript#58099: Function lacks ending return statement and return type does not include 'undefined'
• (73%) microsoft/typescript#18851: Switch on interface with single case not considered exhaustive
• (72%) microsoft/typescript#9838: Exhaustive switch on a type union with a default case yields TS2339: Property 'x' does not exist on type 'never'
• (72%) microsoft/typescript#31677: Consider allowing runtime error handling against object properties in switch default branches
• (72%) microsoft/typescript#47538: Incorrect hover shown for union variable in `while` loop following an exhaustive `switch`
• (72%) microsoft/typescript#29496: Partial type fails to narrow in spite of check for undefined

If your issue is a duplicate of one of these, feel free to close this issue. Otherwise, no action is needed.

[aryzing]

Some context: given a relatively frequently changing discriminated union, at times the disc union is reduced to just a single element. It's annoying to have to change the entire switch structure just because the disc union got reduced to a single variant.

E.g.:

type DiscUnion = A | B

// next day
type DiscUnion = A | B | C | D

// next day
type DiscUnion = C // <-- And the switch breaks