TypeScript 5.8 Major Speed Up

The TypeScript team has released version 5.8. The release focuses on improving compilation performance and refining type-checking rules.

For large codebases, this update reduces the time spent waiting for editor diagnostics.

Optimized Return Type Checking

TypeScript 5.8 optimizes how the compiler checks return types in functions. In previous versions, checking complex union returns required a large amount of memory.

The new compiler uses a more efficient lookup algorithm.

This speeds up type-checking on projects that make heavy use of generics and conditional types. For example, when resolving heavily nested ternary types inside generic hooks, editor response speeds have improved by up to 20%:

// Example of a complex return type checker optimized in 5.8
type RouteResult<T> = T extends { slug: string } 
  ? { data: T; active: boolean } 
  : { error: string };

function resolveRoute<T>(input: T): RouteResult<T> {
  if (input && typeof input === 'object' && 'slug' in input) {
    return { data: input, active: true } as any;
  }
  return { error: "Invalid route" } as any;
}

Faster Incremental Builds

Incremental build compilation has been improved. The compiler is now smarter about detecting which files need to be rechecked when a change occurs.

This reduces subsequent build times during local development.

It helps maintain a fast feedback loop when modifying core type definitions.

Preservation of Type Annotations

TypeScript 5.8 introduces a flag to preserve type annotations in the generated JavaScript. This is useful for compilers and bundlers that perform separate type checks.

Specifically, the new --erasableSyntaxOnly flag ensures that only standard type annotations (which can be easily stripped out) are used.

It disables runtime-impacting TypeScript features like enums, namespaces, and parameter properties:

// tsconfig.json example
{
  "compilerOptions": {
    "module": "NodeNext",
    "target": "ES2022",
    "erasableSyntaxOnly": true,
    "noEmit": true
  }
}

This prevents accidental leaks of TypeScript-specific compiler output in bundlers like esbuild or swc, leading to faster type-erasure compiles.