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

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
    }
}

[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]

@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;
    }
  })
}