TypeScript 5.5: Inferred Type Predicates and the End of Type Guards

TypeScript 5.5 at a Glance

TypeScript 5.5 is a quality-of-life release focused on eliminating boilerplate, speeding up large codebases, and catching more bugs at the syntax level. The standout feature - inferred type predicates - closes a gap that has frustrated TypeScript developers for years.

Inferred Type Predicates

Previously, if you wrote a filter function, TypeScript could not narrow the resulting array type automatically. You had to write an explicit type predicate:

// TypeScript 5.4  -  you had to write the type predicate manually
function isString(x: unknown): x is string {
  return typeof x === "string";
}

const mixed: (string | number)[] = ["a", 1, "b", 2];
const strings = mixed.filter(isString); // string[]

In TypeScript 5.5, TypeScript infers the type predicate from the function body. You no longer need to annotate it:

// TypeScript 5.5  -  inferred automatically
function isString(x: unknown) {
  return typeof x === "string";
}

const strings = mixed.filter(isString); // string[] ✓ inferred correctly

// Works with arrow functions too
const onlyUsers = items.filter((item): item is User => item.type === "user");
// Now just:
const onlyUsers = items.filter(item => item.type === "user"); // User[]

This works for any function where TypeScript can trace the return type back to a type check. It handles typeof, instanceof, discriminated union checks, and more.

--isolatedDeclarations for Monorepos

Large monorepos with hundreds of packages spend significant build time computing declaration files. --isolatedDeclarations enforces that every exported symbol has an explicit type annotation, enabling parallel declaration generation without cross-package analysis:

{
  "compilerOptions": {
    "isolatedDeclarations": true,
    "declaration": true
  }
}

// Error with --isolatedDeclarations: return type must be explicit
export function getUser(id: string) {        // ✗
  return db.users.findOne(id);
}

// Correct
export function getUser(id: string): Promise<User | null> {  // ✓
  return db.users.findOne(id);
}

The payoff: build tools like Turborepo and Vite can now generate .d.ts files for each package in parallel, cutting declaration emit time by 50%+ on large monorepos.

Regular Expression Syntax Checking

TypeScript 5.5 parses regex literals and reports syntax errors inside the editor. No plugin needed:

const pattern = /(?<=foo)bar/;    // ✓ valid lookbehind
const broken  = /(?<=)/;          // ✗ Error: Invalid regular expression
const named   = /(?<year>d{4})/; // ✓ named capture group recognized

This catches typos in regex that previously only surfaced at runtime.

Performance Improvements

TypeScript 5.5 ships a number of internal compiler improvements:

• ~50% faster type checking on large codebases in common patterns
• Faster --watch mode for incremental builds
• Reduced memory usage for large union types
• Monomorphic object shapes for the checker's internal structures

Benchmark on a 500k-line codebase: full tsc --noEmit went from 42s → 28s.

@satisfies Tag in JSDoc

The satisfies operator (added in 5.0) is now available in JSDoc for plain JavaScript projects:

/** @type {import('./types').Config} */
const config = /** @satisfies {import('./types').Config} */ ({
  port: 3000,
  host: "localhost",
});

Upgrading

pnpm add -D typescript@5.5

5.5 has no breaking changes for most codebases. The one edge case: if you had functions that accidentally returned different types in different branches, TypeScript may now infer a more precise type that surfaces previously hidden errors. These are real bugs - fix them.

References: TypeScript 5.5 announcement · playground