How to fix A function whose declared type is neither 'void' nor 'any' must return a value in TypeScript

// WRONG - declares number but doesn't return
function logValue(x: number): number {
  console.log(x);
  // Missing return statement
}

// CORRECT - if function only logs, use void
function logValue(x: number): void {
  console.log(x);
  // No return needed for void
}

// CORRECT - if function should return, add return statement
function doubleValue(x: number): number {
  console.log(x);
  return x * 2;
}

// BEFORE: Error - no return statement
function calculateTotal(price: number, tax: number): number {
  const total = price + (price * tax);
  // Missing: return total;
}

// AFTER: Add return statement
function calculateTotal(price: number, tax: number): number {
  const total = price + (price * tax);
  return total;
}

// Or more concisely
function calculateTotal(price: number, tax: number): number {
  return price + (price * tax);
}

// BEFORE: Error - explicit return type but no return
const add = (a: number, b: number): number => {
  a + b; // This doesn't return!
};

// AFTER: Add explicit return
const add = (a: number, b: number): number => {
  return a + b;
};

// Or use implicit return (no braces)
const add = (a: number, b: number): number => a + b;

// BEFORE: Error - else branch missing return
function getStatus(code: number): string {
  if (code === 200) {
    return "OK";
  } else if (code === 404) {
    return "Not Found";
  }
  // Missing: what if code is neither 200 nor 404?
}

// AFTER: Add return for all paths
function getStatus(code: number): string {
  if (code === 200) {
    return "OK";
  } else if (code === 404) {
    return "Not Found";
  }
  return "Unknown"; // Default case
}

// Or use a switch with default
function getStatus(code: number): string {
  switch (code) {
    case 200:
      return "OK";
    case 404:
      return "Not Found";
    default:
      return "Unknown";
  }
}

// BEFORE
function getMessage(success: boolean): string {
  return success ? "Success" : undefined; // undefined doesn't match string
}

// AFTER
function getMessage(success: boolean): string {
  return success ? "Success" : "Failed";
}

// BEFORE: Error - async function must return Promise<User>
async function getUser(id: string): Promise<User> {
  const response = await fetch(`/api/users/${id}`);
  const user = await response.json();
  // Missing: return user;
}

// AFTER: Add return statement
async function getUser(id: string): Promise<User> {
  const response = await fetch(`/api/users/${id}`);
  const user = await response.json();
  return user;
}

// Or directly return the promise
async function getUser(id: string): Promise<User> {
  const response = await fetch(`/api/users/${id}`);
  return response.json();
}

// BEFORE: Must return Promise<number>
function delayedCalculation(): Promise<number> {
  setTimeout(() => {
    return 42; // This returns from the callback, not the function!
  }, 1000);
}

// AFTER: Wrap in a promise
function delayedCalculation(): Promise<number> {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve(42);
    }, 1000);
  });
}

// BEFORE: Incorrectly typed as string
function displayMessage(msg: string): string {
  console.log(msg);
  // No return statement - this is a side effect only
}

// AFTER: Change to void
function displayMessage(msg: string): void {
  console.log(msg);
}

// For event handlers in React/DOM
const handleClick = (e: MouseEvent): void => {
  console.log("Clicked!");
  e.preventDefault();
  // No return needed
};

// TypeScript doesn't recognize throw as terminal
function assertNever(value: never): never {
  throw new Error(`Unexpected value: ${value}`);
}

// Use 'never' return type for functions that always throw or exit
function exitWithError(msg: string): never {
  console.error(msg);
  process.exit(1);
}

// BEFORE: TypeScript doesn't know this throws
function validateUser(user: unknown): User {
  if (!user || typeof user !== "object") {
    throw new Error("Invalid user");
  }
  // TypeScript still expects a return here
}

// AFTER: Use assertion signature (asserts)
function validateUser(user: unknown): asserts user is User {
  if (!user || typeof user !== "object") {
    throw new Error("Invalid user");
  }
  // No return needed - this is an assertion function
}

// Or return a type guard
function isUser(user: unknown): user is User {
  return user !== null &&
         typeof user === "object" &&
         "id" in user;
}

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

function handleStatus(status: Status): string {
  switch (status) {
    case "pending":
      return "Loading...";
    case "success":
      return "Done!";
    case "error":
      return "Failed";
    default:
      // Ensures all cases are handled
      const _exhaustive: never = status;
      return _exhaustive;
  }
}