How to fix An expression of type 'never' cannot be tested against a string, number, or other type in TypeScript

type Status = 'pending' | 'success' | 'error';

function handleStatus(status: Status) {
  if (status === 'pending') {
    console.log('Pending...');
  } else if (status === 'success') {
    console.log('Success!');
  }
  // At this point, TypeScript knows status is 'error' (not 'never' yet)

  if (typeof status === 'string') {  // ERROR: status is 'never' here if all cases handled
    console.log('This will never run');
  }
}

function assertNever(value: never): never {
  throw new Error(`Unhandled value: ${value}`);
}

type Shape =
  | { kind: 'circle'; radius: number }
  | { kind: 'square'; side: number }
  | { kind: 'triangle'; base: number; height: number };

function getArea(shape: Shape): number {
  switch (shape.kind) {
    case 'circle':
      return Math.PI * shape.radius ** 2;
    case 'square':
      return shape.side ** 2;
    case 'triangle':
      return 0.5 * shape.base * shape.height;
    default:
      // TypeScript knows shape is 'never' here if all cases covered
      return assertNever(shape); // Compile-time error if cases missing
  }
}

type Result<T> =
  | { type: 'success'; data: T }
  | { type: 'error'; message: string }
  | { type: 'loading' };

function processResult<T>(result: Result<T>) {
  if (result.type === 'success') {
    console.log(result.data);
  } else if (result.type === 'error') {
    console.error(result.message);
  } else if (result.type === 'loading') {
    console.log('Loading...');
  }
  // All cases covered, no 'never' type

  // This would cause the error if we didn't handle 'loading':
  // if (typeof result.type === 'string') { ... }
}

// ❌ WRONG - TypeScript knows x is 'never' after the switch
function badExample(x: 'a' | 'b') {
  switch (x) {
    case 'a': return 1;
    case 'b': return 2;
  }

  if (typeof x === 'string') {  // ERROR: x is 'never'
    console.log('Unreachable');
  }
}

// ✅ CORRECT - No additional checks after exhaustive handling
function goodExample(x: 'a' | 'b') {
  switch (x) {
    case 'a': return 1;
    case 'b': return 2;
  }

  // No code here - function returns in all cases
}

// ✅ ALTERNATIVE - Use default case for exhaustiveness
function betterExample(x: 'a' | 'b') {
  switch (x) {
    case 'a': return 1;
    case 'b': return 2;
    default:
      const exhaustiveCheck: never = x;
      return exhaustiveCheck;
  }
}

interface Admin { role: 'admin'; permissions: string[] }
interface User { role: 'user'; email: string }
interface Guest { role: 'guest' }

type Person = Admin | User | Guest;

function isAdmin(person: Person): person is Admin {
  return person.role === 'admin';
}

function isUser(person: Person): person is User {
  return person.role === 'user';
}

function isGuest(person: Person): person is Guest {
  return person.role === 'guest';
}

function getAccessLevel(person: Person) {
  if (isAdmin(person)) {
    return 'full';
  } else if (isUser(person)) {
    return 'limited';
  } else if (isGuest(person)) {
    return 'read-only';
  }

  // TypeScript knows all cases are covered
  // No 'never' error when adding proper type guards
}

{
  "compilerOptions": {
    "strict": true,
    "noImplicitAny": true,
    "strictNullChecks": true,
    "strictFunctionTypes": true,
    "strictBindCallApply": true,
    "strictPropertyInitialization": true,
    "noImplicitThis": true,
    "alwaysStrict": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "noImplicitReturns": true,
    "noFallthroughCasesInSwitch": true,
    "exactOptionalPropertyTypes": true,
    "noUncheckedIndexedAccess": true
  }
}