How to fix Function lacks ending return statement and return type does not include 'undefined' in TypeScript

TypeScriptINTERMEDIATEMEDIUMUpdated Dec 10, 2025· 120 views

This TypeScript compiler error occurs when a function with an explicit return type does not return a value from all code paths. The compiler detects that some execution branches may reach the end of the function without returning a value, which violates the declared return type.

Quick fix

Fixes TS2366

// PROBLEM: If condition is false, function returns nothing
function getDiscount(isPremium: boolean): number {
  if (isPremium) {
    return 20;
  }
  // Missing return here - function ends without returning a value
}
  1. Identify which code path is missing a return statement
  2. Add return statements to all code paths
  3. Update return type to include undefined
  4. Use exhaustiveness checking for union types
typescript — error
// PROBLEM: If condition is false, function returns nothing
function getDiscount(isPremium: boolean): number {
  if (isPremium) {
    return 20;
  }
  // Missing return here - function ends without returning a value
}
Function lacks ending return statement and return type does not include 'undefined'

What this error means

TypeScript performs comprehensive code path analysis to ensure type safety. When you declare a function with a specific return type, TypeScript expects every possible execution path through that function to return a value matching that type. Error TS2366 occurs when TypeScript detects that at least one code path can reach the end of the function without encountering a return statement. This commonly happens with: 1. **Incomplete conditional branches**: If/else statements where not all branches return a value 2. **Missing default cases**: Switch statements that don't handle all possibilities 3. **Early returns without fallback**: Functions that return early in some conditions but lack a final return 4. **Async functions with incomplete error handling**: Try/catch blocks where the catch block doesn't return This error is TypeScript's way of preventing runtime bugs where your function might unexpectedly return `undefined` when callers expect a specific type. The strictness helps catch logic errors during development rather than at runtime.

Typical symptoms

  • TypeScript compilation fails with error TS2366
  • Red squiggly line under the function signature in your IDE
  • Error message points to the function declaration, not a specific line
  • Function works in JavaScript but fails TypeScript type checking
  • Issue appears after adding an explicit return type to a function
  • Error occurs in functions with conditional logic (if/else, switch)
  • Problem manifests in async functions with try/catch blocks

Common causes

  1. If/else statement where only some branches contain return statements
  2. Switch statement missing a default case or not all cases return a value
  3. Function with early returns in conditional blocks but no final return statement
  4. Try/catch block where the catch block doesn't return a value
  5. Conditional logic that TypeScript cannot verify covers all possible cases
  6. Function declared with specific return type (e.g., string) when it should allow undefined
  7. Removing a return statement without updating the function's return type annotation
  8. Complex nested conditions where not all paths are explicitly handled

How to fix "Function lacks ending return statement and return type does not include 'undefined'"

1Identify which code path is missing a return statement

First, analyze your function to find which execution path doesn't return a value. Look for conditional branches that might not return:

typescript
// PROBLEM: If condition is false, function returns nothing
function getDiscount(isPremium: boolean): number {
  if (isPremium) {
    return 20;
  }
  // Missing return here - function ends without returning a value
}

Check your function logic:
- Trace each if/else if/else branch
- Verify every switch case has a return or a default case exists
- Look for early returns that bypass a final return statement
- Check both try and catch blocks in error handling

2Add return statements to all code paths

The most straightforward fix is ensuring every possible path through your function returns a value:

typescript
// BEFORE: Error TS2366
function getDiscount(isPremium: boolean): number {
  if (isPremium) {
    return 20;
  }
  // Missing return
}

// AFTER: All paths return a value
function getDiscount(isPremium: boolean): number {
  if (isPremium) {
    return 20;
  }
  return 0; // Default return for non-premium users
}

For switch statements:

typescript
// BEFORE: Error TS2366
function getStatus(code: number): string {
  switch (code) {
    case 200:
      return "Success";
    case 404:
      return "Not Found";
    // Missing default case
  }
}

// AFTER: Default case added
function getStatus(code: number): string {
  switch (code) {
    case 200:
      return "Success";
    case 404:
      return "Not Found";
    default:
      return "Unknown Status";
  }
}
3Update return type to include undefined

If your function legitimately may not return a value in some cases, update the return type to allow undefined:

typescript
// BEFORE: Error TS2366
function findUser(id: number): User {
  if (users.has(id)) {
    return users.get(id);
  }
  // No user found - no return
}

// AFTER: Return type allows undefined
function findUser(id: number): User | undefined {
  if (users.has(id)) {
    return users.get(id);
  }
  // Implicit return of undefined is now valid
}

// Or be explicit
function findUser(id: number): User | undefined {
  if (users.has(id)) {
    return users.get(id);
  }
  return undefined; // Explicit undefined return
}

For async functions:

typescript
// BEFORE: Error TS2366
async function fetchData(): Promise<string> {
  try {
    const response = await fetch(url);
    return response.text();
  } catch (err) {
    console.error(err);
    // No return in catch block
  }
}

// AFTER: Include undefined in return type
async function fetchData(): Promise<string | undefined> {
  try {
    const response = await fetch(url);
    return response.text();
  } catch (err) {
    console.error(err);
    return undefined;
  }
}
4Use exhaustiveness checking for union types

For discriminated unions, use exhaustiveness checking to ensure all cases are handled:

typescript
type Shape =
  | { kind: "circle"; radius: number }
  | { kind: "square"; size: number }
  | { kind: "rectangle"; width: number; height: number };

// BEFORE: Error TS2366 if a new shape is added
function getArea(shape: Shape): number {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2;
    case "square":
      return shape.size ** 2;
    // Missing rectangle case
  }
}

// AFTER: Exhaustiveness check catches missing cases
function getArea(shape: Shape): number {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2;
    case "square":
      return shape.size ** 2;
    case "rectangle":
      return shape.width * shape.height;
    default:
      // This will error if a case is missing
      const _exhaustive: never = shape;
      throw new Error(`Unhandled shape: ${_exhaustive}`);
  }
}

This pattern ensures TypeScript will error if you add a new shape type but forget to handle it in the switch.

5Handle early returns with a final fallback

If your function has multiple early returns, add a final return statement as a safety net:

typescript
// BEFORE: Error TS2366
function processValue(value: string | null): string {
  if (value === null) {
    return "No value";
  }
  if (value.length === 0) {
    return "Empty";
  }
  if (value.length > 100) {
    return "Too long";
  }
  // TypeScript can't verify all cases are covered
}

// AFTER: Final return as fallback
function processValue(value: string | null): string {
  if (value === null) {
    return "No value";
  }
  if (value.length === 0) {
    return "Empty";
  }
  if (value.length > 100) {
    return "Too long";
  }
  return value; // Fallback for all other cases
}

For complex logic, consider refactoring into smaller functions:

typescript
function processValue(value: string | null): string {
  if (value === null) return "No value";
  return validateLength(value);
}

function validateLength(value: string): string {
  if (value.length === 0) return "Empty";
  if (value.length > 100) return "Too long";
  return value;
}
6Enable noImplicitReturns for stricter checking

To catch these issues earlier in development, enable the noImplicitReturns compiler option in your tsconfig.json:

json
{
  "compilerOptions": {
    "noImplicitReturns": true,
    "strict": true
  }
}

This option makes TypeScript check every code path in functions with return types, catching potential bugs where return statements are missing. It works alongside strictNullChecks to enforce consistent return behavior.

You can also enable individual strict options:

json
{
  "compilerOptions": {
    "strictNullChecks": true,
    "noImplicitReturns": true,
    "strictFunctionTypes": true
  }
}

These settings help prevent common runtime errors by enforcing stricter compile-time checks.

Advanced notes

### Understanding void vs undefined

TypeScript distinguishes between void and undefined:

- void: Indicates a function is not meant to return a value (side effects only)
- undefined: A specific value that can be returned and used

typescript
// void - no return value expected
function logMessage(msg: string): void {
  console.log(msg);
  // No return statement needed
}

// undefined - explicitly returns undefined
function maybeGetValue(): string | undefined {
  if (Math.random() > 0.5) {
    return "value";
  }
  return undefined; // Explicit return of undefined
}

Functions declared with void return type can omit return statements entirely, while functions with other return types (including undefined) must return on all paths.

### Control Flow Analysis Limitations

TypeScript's control flow analysis is sophisticated but not perfect. It may fail to recognize that your code always returns:

typescript
function getValue(input: 1 | 2 | 3): string {
  if (input === 1) return "one";
  if (input === 2) return "two";
  if (input === 3) return "three";
  // TypeScript might still require a return here
}

When this happens, add an explicit final return (even if unreachable):

typescript
function getValue(input: 1 | 2 | 3): string {
  if (input === 1) return "one";
  if (input === 2) return "two";
  if (input === 3) return "three";

  // Unreachable in practice, but satisfies TypeScript
  throw new Error("Unexpected input");
  // Or: return "" as never;
}

### Asserting Unreachable Code

For unreachable code paths, use a never assertion:

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

function handleValue(input: "a" | "b"): string {
  switch (input) {
    case "a":
      return "handled a";
    case "b":
      return "handled b";
    default:
      return assertNever(input); // Ensures exhaustiveness
  }
}

This pattern leverages TypeScript's type system to guarantee all cases are covered at compile time.

### Common Async Pitfalls

Async functions always return promises. Make sure your return type reflects this:

typescript
// WRONG - should return Promise<string>
async function getData(): string {
  return fetch(url).then(r => r.text());
}

// CORRECT
async function getData(): Promise<string> {
  return fetch(url).then(r => r.text());
}

// With error handling
async function getData(): Promise<string | undefined> {
  try {
    return await fetch(url).then(r => r.text());
  } catch {
    return undefined; // Must return in catch block too
  }
}

### React Component Return Types

React functional components should return JSX or null, not undefined:

typescript
// WRONG - components cannot return undefined
function MyComponent(): JSX.Element {
  if (!data) {
    return; // Error: lacks return statement
  }
  return <div>{data}</div>;
}

// CORRECT - return null for empty renders
function MyComponent(): JSX.Element | null {
  if (!data) {
    return null;
  }
  return <div>{data}</div>;
}

Frequently asked questions

What does "TS2366" mean?
TypeScript performs comprehensive code path analysis to ensure type safety. When you declare a function with a specific return type, TypeScript expects every possible execution path through that function to return a value matching that type. Error TS2366 occurs when TypeScript detects that at least one code path can reach the end of the function without encountering a return statement.
How do I fix "TS2366"?
This TypeScript compiler error occurs when a function with an explicit return type does not return a value from all code paths. The compiler detects that some execution branches may reach the end of the function without returning a value, which violates the declared return type.
What causes "TS2366"?
If/else statement where only some branches contain return statements Switch statement missing a default case or not all cases return a value Function with early returns in conditional blocks but no final return statement
Is the "TS2366" error serious?
It is a medium-severity error — more of a blocker than a risk. The steps above resolve it.

Official resources & further reading