Type instantiation is excessively deep with tuple spread

Bug Report

🔎 Search Terms

• 2889 spread

🕗 Version & Regression Information

• This is the behavior in every version I tried (4.1.5 to 5.2.0 nightly), and I reviewed the FAQ for entries about: recursion

⏯ Playground Link

Playground link with relevant code

💻 Code

type NTuple<T, N extends number, Acc extends T[] = []> =
  N extends Acc['length']
  ? Acc
  : NTuple<T, N, [...Acc, T]>

type Pair = NTuple<number, 2>;
//   ^? type Pair = [number, number]

type SpreadN<A extends number> = [...NTuple<any, A>]
//                               ~~~~~~~~~~~~~~~~~~~
// Type instantiation is excessively deep and possibly infinite. (2589)

🙁 Actual behavior

I'm getting the "Type instantiation is excessively deep and possibly infinite. (2589)" error on what should be the identity.

🙂 Expected behavior

I'd expect this to just work. SpreadN should produce the same results as NTuple. It's surprising to me that this error is produced on the definition of SpreadN, rather than when it's instantiated with an overly large value of N.

I think this may have something to do with distribution over unions because when I reverse the conditional, the code works fine:

type NTuple2<T, N extends number, Acc extends T[] = []> =
  Acc['length'] extends N  // note that the check is reversed
  ? Acc
  : NTuple2<T, N, [...Acc, T]>

type SpreadN2<A extends number> = [...NTuple<any, A>]  // ok
type Pair2 = SpreadN2<2>;
//   ^? type Pair2 = [any, any]

It's not clear to me why reversing that conditional would matter, but it does have the effect of preventing distribution over unions, which is not desirable:

type T1 = NTuple<string, 2 | 3>;
//   ^? type T1 = [string, string] | [string, string, string]
type T2 = NTuple2<string, 2 | 3>;
//   ^? type T2 = [string, string]

Start by reproducing the tuple-spread example in the linked TypeScript Playground and compare NTuple with NTuple2, including their behavior over unions. Done means SpreadN no longer reports error 2589 at its definition while NTuple retains the expected distributed union results.