How to fix Expression is not assignable to 'never' in TypeScript

// BEFORE: Error - cannot push to never[]
const items = [];
items.push("hello"); // Error: Argument of type 'string' is not assignable to parameter of type 'never'

// AFTER: Explicitly type the array
const items: string[] = [];
items.push("hello"); // OK

// Or use initial value to help TypeScript infer
const items = ["initial"]; // Inferred as string[]
items.push("hello"); // OK

// For arrays of objects
const users: { name: string; id: number }[] = [];
users.push({ name: "Alice", id: 1 }); // OK

// Or with a type alias
type User = { name: string; id: number };
const users: User[] = [];
users.push({ name: "Alice", id: 1 }); // OK

// BEFORE: Over-narrowing creates 'never'
type Status = "pending" | "success" | "error";

function handleStatus(status: Status) {
  if (status !== "pending" && status !== "success" && status !== "error") {
    // TypeScript knows this is impossible - status is 'never' here
    console.log(status); // Type is 'never'
  }
}

// BETTER: Use exhaustive checks properly
function handleStatus(status: Status) {
  if (status === "pending") {
    console.log("Pending...");
  } else if (status === "success") {
    console.log("Success!");
  } else if (status === "error") {
    console.log("Error!");
  } else {
    // This should never execute - use for exhaustiveness checking
    const _exhaustive: never = status;
    throw new Error(`Unhandled status: ${_exhaustive}`);
  }
}

// Example with contradictory type guards
type Result = { success: true; data: string } | { success: false; error: string };

function process(result: Result) {
  // WRONG: This creates impossible condition
  if (result.success === true && result.success === false) {
    // result is 'never' here - impossible state
    console.log(result);
  }

  // CORRECT: Use proper narrowing
  if (result.success) {
    console.log(result.data); // TypeScript knows success=true case
  } else {
    console.log(result.error); // TypeScript knows success=false case
  }
}

// BEFORE: React state inferred as never[]
import { useState } from "react";

function TodoList() {
  const [todos, setTodos] = useState([]);

  const addTodo = (text: string) => {
    setTodos([...todos, { id: Date.now(), text }]);
    // Error: Type '{ id: number; text: string; }' is not assignable to type 'never'
  };

  return <div>...</div>;
}

// AFTER: Explicitly type the state
import { useState } from "react";

type Todo = { id: number; text: string };

function TodoList() {
  const [todos, setTodos] = useState<Todo[]>([]);

  const addTodo = (text: string) => {
    setTodos([...todos, { id: Date.now(), text }]); // OK
  };

  return <div>...</div>;
}

// For complex state shapes
type AppState = {
  users: User[];
  posts: Post[];
  loading: boolean;
};

const [state, setState] = useState<AppState>({
  users: [],
  posts: [],
  loading: false,
});

// BEFORE: Impossible generic constraint
type Impossible<T extends string & number> = T; // T is 'never' - nothing can be both string AND number

function process<T extends string & number>(value: T) {
  return value; // T is 'never' here
}

// AFTER: Use union instead of intersection when appropriate
type StringOrNumber<T extends string | number> = T; // OK - T can be string OR number

function process<T extends string | number>(value: T) {
  return value; // OK
}

// Example with array methods
const numbers = [1, 2, 3];
const filtered = numbers.filter((n) => n > 5); // May be empty, but still number[]

// If you further narrow incorrectly:
const items: (string | number)[] = ["a", 1];
const result = items.filter((x): x is string => typeof x === "string")
                     .filter((x): x is number => typeof x === "number");
// result is 'never[]' - nothing can be both string AND number

// BEFORE: TypeScript incorrectly infers never
const data = JSON.parse(response); // Type is 'any'
const filtered = data.filter((x: any) => x.active); // Might be inferred as never[]

// AFTER: Assert the correct type
type User = { id: number; name: string; active: boolean };
const data = JSON.parse(response) as User[];
const filtered = data.filter((x) => x.active); // Type is User[]

// Alternative: Use type guard
function isUserArray(value: unknown): value is User[] {
  return Array.isArray(value) && value.every(
    (item) => typeof item === "object" &&
              "id" in item &&
              "name" in item
  );
}

const data = JSON.parse(response);
if (isUserArray(data)) {
  const filtered = data.filter((x) => x.active); // OK
}