TS2589 regression in 6.0: implements without type parameters causes excessive type instantiation when property uses concrete generic type

[julienw]

🔎 Search Terms

Type instantiation is excessively deep and possibly infinite.

🕗 Version & Regression Information

• This changed between versions 5.9.3 and 6.0.2

⏯ Playground Link

https://www.typescriptlang.org/play/?target=7#code/JYWwDg9gTgLgBDAnmApnA3nAShArjFKAGQgGMBDGYCAOwBo4B1FAIwGEJxaUaYBJXoQBm5UmgC+cIVE5wARAAEAbuXIATYDQD0M-ITkBuAFBGkqbHgIBRAB7wAvBjgBnFKSq0A-AC4XMKJoA5nDixkZaWnAAKgDKAEwArAAcAJxwtAgAFmikADbkzs5wam75UJTUNHAsKLkQAO4AdOGRAGLANr5QKGD5YnAABszsnJA0PPyCUCJiA3D1wDCZg8McXOO8AgTToigAPDh6tjAAfAPNES1wAHIQBL5LaIQyUOk0uYgIAYGBhEU1FFwrkGdQoHhoc2ARTMKDU80Wy3IcFItFI3QICGQKCuYHI5RAKG2cAAFANDtsSGDKgdLChjmcAJSNOAAVWcQUG5MIlIqtDmCyWljgSJhOLx5AJRLUEBQRRody+wB+hDgi2aKBskFgyPyhTgAFlEFZcigCbw4BqCDQ1EUABJRfVEY2miaq8Ams0wIqrUbcTZTGZodBGOBwUG8mg+Cx6YhkCM0o52E7GcRGIA

💻 Code

import type { RouterLocation, WebComponentInterface } from "@vaadin/router";

type RouteExt = { section?: string };

// TS2589 on the class declaration below.
// Fix: replace `WebComponentInterface` with `WebComponentInterface<RouteExt>`.
//
// Note: the error only triggers because `location` is typed with a concrete type
// parameter (`RouterLocation<RouteExt>`). Using `RouterLocation` without a type
// parameter does not trigger it.
export class MyElement extends HTMLElement implements WebComponentInterface {
  location?: RouterLocation<RouteExt>;
}

🙁 Actual behavior

I get this error:

Type instantiation is excessively deep and possibly infinite.

But the information isn't very useful to know what to do exactly in this case.

🙂 Expected behavior

Ideally no error, otherwise some more pointers about how to fix this.

Additional information about the issue

When running with --extendedDiagnostics:

typescript 5.9.3:

     Files:                         259
     Types:                      203241
     Instantiations:            2593860

typescript 6.0.2:

     Files:                         259
     Types:                      217322
     Instantiations:            5379836

[RyanCavanaugh]

"minimal" repro courtesy a very long AI session:

// Inlined from type-fest
type EmptyObject = {};

type RequireAtLeastOne<
  T,
  K extends keyof T = keyof T,
> = {
  [P in K]-?: Required<Pick<T, P>> &
    Partial<Pick<T, Exclude<K, P>>>;
}[K];

type BaseNode<V = unknown, R extends object = EmptyObject, C extends object = EmptyObject> = {
  children?: Array<BaseNode<V, R, C>>;
} & R;

type BaseRef<V, R extends object, C extends object> = {
  node: BaseNode<V, R, C>;
};

type CtxExt<R extends object, C extends object> = {
  ref?: Ref<R, C>;
} & C;

type NodeExt<R extends object, C extends object> = RequireAtLeastOne<{
  children?: (() => Node<R, C>) | Array<Node<R, C>>;
  a?: string;
  b?: string;
  ctx?: CtxExt<R, C>;
}> & R;

type Node<R extends object = EmptyObject, C extends object = EmptyObject> =
  BaseNode<HTMLElement, NodeExt<R, C>, CtxExt<R, C>>;

type Ref<R extends object, C extends object> =
  BaseRef<HTMLElement, NodeExt<R, C>, CtxExt<R, C>> & {
    element?: Iface<R, C>;
  };

interface Location<R extends object = EmptyObject, C extends object = EmptyObject> {
  node: Node<R, C> | null;
}

interface Iface<R extends object = EmptyObject, C extends object = EmptyObject> extends HTMLElement {
  location?: Location<R, C>;
}

// TS2589: implements Iface (without type args) + concrete Location<Ext> triggers excessive instantiation
type Ext = { extra?: string };
export class MyElement extends HTMLElement implements Iface {
  location?: Location<Ext>;
}

Copilot says this, I dunno if I believe it

Key ingredients that all must be present:

 1. RequireAtLeastOne mapped type with 4+ keys (including union children + a method/property returning the context type)
 2. Recursive BaseNode type (self-referential via children)
 3. 3-param type indirection (BaseNode<V,R,C>, BaseRef<V,R,C>) — inlining these kills the bug
 4. Mutual recursion: Iface → Location → Node → NodeExt → CtxExt → Ref → back to Iface
 5. Intersection with type params (& R, & C)

[RyanCavanaugh]

Bisects to #62604

[RyanCavanaugh]

I don't know what this corresponds to in the original repro, but adding a few variance annotations is sufficient to prevent the problem:

interface Location<out R extends object = EmptyObject, out C extends object = EmptyObject> {
  node: Node<R, C> | null;
}

interface Iface<out R extends object = EmptyObject, out C extends object = EmptyObject> extends HTMLElement {
  location?: Location<R, C>;
}

This doesn't repro in TS 7, and the originating PR is a necessary correctness change, so this isn't going to meet the 6.0 patch bar.

[RyanCavanaugh]

Slightly smaller repro, though it's still a lot:

type RequireAtLeastOne<T> = {
  [K in keyof T]-?: Required<Pick<T, K>> &
    Partial<Pick<T, Exclude<keyof T, K>>>;
}[keyof T];

type BaseNode<R = {}> = {
  children?: BaseNode<R>[];
} & R;

type BaseRef<R> = {
  node: R;
};

type NodeExt<R, C> = RequireAtLeastOne<{
  children?: TreeNode<R, C> | TreeNode<R, C>[];
  a?: string;
  b?: string;
  ref?: Ref<R, C>;
}> & R;

type TreeNode<R = {}, C = {}> =
  BaseNode<NodeExt<R, C>>;

type Ref<R, C> =
  BaseRef<NodeExt<R, C>> & {
    element?: Iface<R, C>;
  };

interface Iface<R = {}, C = {}> {
  location?: TreeNode<R, C>;
}

// TS2589: implements Iface (without type args) + concrete TreeNode<{x:string}> triggers excessive instantiation
class MyElement implements Iface {
  location?: TreeNode<{ x: string }>;
}

[julienw]

Thanks for looking!

FWIW claude helped me looking at the instantiations with/without the fix (the fix being explicitly specifying the generic parameter).

  ┌────────────┬───────┬────────────────┐                                                                                                                                                                                                                                                                                                                                                                                    
  │ TypeScript │ Code  │ Instantiations│                                                                                                                                                                                                                                                                                                                                                                                              
  ├────────────┼───────┼────────────────┤                                                                                                                                                                                                                                                                                                                                                                                               
  │ 5.9.3      │ buggy │ 2,593,860     │                                                                                                                                                                                                                                                                                                                                                                                               
  ├────────────┼───────┼────────────────┤                                                                                                                                                                                                                                                                                                                                                                                               
  │ 5.9.3      │ fixed │ 345,899       │                                                                                                                                                                                                                                                                                                                                                                                               
  ├────────────┼───────┼────────────────┤                                                                                                                                                                                                                                                                                                                                                                                               
  │ 6.0.2      │ buggy │ 5,379,836     │                                                                                                                                                                                                                                                                                                                                                                                               
  ├────────────┼───────┼────────────────┤                                                                                                                                                                                                                                                                                                                                                                                               
  │ 6.0.2      │ fixed │ 379,958       │                                                                                                                                                                                                                                                                                                                                                                                             
  └────────────┴───────┴────────────────┘

The project where these types come from is now in maintainance mode but I guess I could try to add some variance annotations; although it's probably easier for me to just specify the parameter 😅