Recursive tuple cannot be computed through generic, but valid in a declarative form

🔎 Search Terms

ts2589 "Type instantiation is excessively deep and possibly infinite"

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about ts2589
• I was unable to test this on prior versions before v4.7.0 because infer T extends R syntax not introduced

⏯ Playground Link

https://www.typescriptlang.org/play/?ts=5.9.3#code/C4TwDgpgBAYg9nKBeKBvAUFKAbCBDAEwEsA7AcwC4oByPagGkygCcIBnYKgbXjgF1GAXwDc6dKEhQAogA8weEgQA8AFQB8yKCqgQZwCIrZomWXIVKUopAGYRmUADKisWVhyo27UAEo69BgiMFEC4+dEEoAH4oLgd6KAA6JNl5RQBZYKVvNT4oKhIIADc7UXFwaBSFAgySEFU-fUMoYNCNJBMtBoCjLk97GCJmDnikhL6fdmBc6K5KxSUBoeA1EeS5Kpq670mcvJi+UoloFUmAQU055V41UQB6W5dHx4A9AD8tcqsSDgVgIjw-nASFYjLoAMbsNhEYrYEBQAgQCBgZqKKBgOBsKEAI1hX2spCI+gSAAoAEwAVgAHABOACUYiOWkmACFNFxaAwmRxmQd0EA

💻 Code

type Foo = {
  leading: 'a',
  rest: [Foo],
};

type Expand<T> = T extends {
    leading: infer L;
    rest: infer R extends any[]
} ? [L, ...ExpandMany<R>] : never;

type ExpandMany<T extends any[]> =
    T extends [infer First, ...infer Rest] ? [Expand<First>, ...ExpandMany<Rest>] : [];

type TestA = Expand<Foo>;
//           ^~ Type instantiation is excessively deep and possibly infinite.(2589)

type TestB = ['a', TestB];

🙁 Actual behavior

TestA meant to be:

TestA
-> Expand<Foo>
-> ['a', ...ExpandMany<[Foo]>]
-> ['a', ...[Expand<Foo>]]
-> ['a', Expand<Foo>]
-> ['a', TestA]

which is identical to TestB but TS complains the instantiation cannot stop.

🙂 Expected behavior

Stop expansion at first reference at appeared structure Expand<Foo>, that is:

type TestA = Expand<Foo>;
//      ^?~ type TestA = ['a', Expand<Foo>]
// or more intelligent `type TestA = ['a', TestA]`

Additional information about the issue

This code is useful when Foo is as const inferred from a runtime constant, and we want a tuple-like typing calculated from Foo. Since TypeScript support self-referential tuple by declarative just like TestB, it would be better for support that in a computed way like Expand<Foo>.

Start with the linked TypeScript Playground example and confirm the TS2589 error for TestA while TestB is accepted. Trace how recursive conditional and tuple types are instantiated, then define completion as allowing the computed form to stabilize at a self-referential tuple without regressing recursion diagnostics.