narrowing in switch doesn't work with non-union types

[zpdDG4gta8XKpMCd]

class A {
 readonly kind = 'a';
}
type U = A; // <-- supposed to be a single case union
declare var u: U;
declare function never(never: never): never;
function fn() {
 switch (u.kind) {
 case 'a': return 1;
 default: return never(u); // <-- u expected to be never, actually is A
 }
}

[RyanCavanaugh]

Currently there's no logic in effect for "narrowing" of non-unions.

It'd be good to collect more use cases where behavior like this could be useful

[zpdDG4gta8XKpMCd]

well, my use case is the consistency with other places where U is a true union (has more than one case)

[DylanRJohnston]

Ryan Cavanaugh (@RyanCavanaugh)

I've also run into this problem when trying to write error handling code that should be extensible with more error cases in the future.

const assertNever = (x: never): never => { throw new Error(`Unexpected object ${x}`) }

type Foo =
 | { kind: 'kind1', x: number }
 // | { kind: 'kind2', y: string }

function foo(f: Foo) {
 switch (f.kind) {
 case 'kind1': return ""
 // case 'kind2': return ""
 default: return assertNever(f)
 }
}

Type error

[ts] Argument of type 'Foo' is not assignable to parameter of type 'never'.

Shouldn't a single value be treated as a union with a single element? So the narrowing here should result in f being narrowed to never?

[zpdDG4gta8XKpMCd]

interestingly narrowing works for single string literals, which is at very least looks inconsistent with this very issue

type U = 'a'; // <-- supposed to be a single case union
declare var u: U;
declare function never(never: never): never;
function fn() {
 switch (u) {
 case 'a': return 1;
 default: return never(u); // <-- WORKS!
 }
}

[Freak613]

Ryan Cavanaugh (@RyanCavanaugh),

Can be useful when designing API that don't have union initially, but later got it:

// Initial
{
 type DbError = {
 tag: "DbError"
 }

 const updateDB = (onError: (error: DbError) => void) => { }

 updateDB(error => {
 switch (error.tag) {
 case "DbError":
 const e1: DbError = error;
 console.log("DbError happened");
 break;
 default:
 // Problem, all possible errors are handled
 const e2: never = error; // Type 'DbError' is not assignable to type 'never'.
 console.log("Unhandled error");
 break;
 }
 })
}

// Sometimes later
{
 type DbError = {
 tag: "DbError"
 }

 type NewDbError = {
 tag: "NewDbError"
 }

 const updateDB = (onError: (error: DbError | NewDbError) => void) => { }

 updateDB(error => {
 switch (error.tag) {
 case "DbError":
 const e1: DbError = error;
 console.log("DbError happened");
 break;
 default:
 // Correct, need to update code to handle new error type
 const e2: never = error; // Type 'NewDbError' is not assignable to type 'never'.
 console.log("Unhandled error");
 break;
 }
 })
}

[jcalz]

cross-referencing to this relevant comment on #8513