Inference fails form unions of arrays of different depths (T[] | T[][])

[dragomirtitian]

Steps to reproduce

declare function flat<T>(args: T[] | T[][]): void;
type Value = 1 | 2
declare const n: Value[] | Value[][]
flat(n)

Behavior with typescript@5.8

Type checks, T is inferred as Value

Behavior with tsgo

We get an error in flat(n):

error TS2345: Argument of type 'Value[][] | Value[]' is not assignable to parameter of type 'Value[][][] | Value[][]'.
  Type 'Value[]' is not assignable to type 'Value[][][] | Value[][]'.
    Type 'Value[]' is not assignable to type 'Value[][][]'.
      Type 'number' is not assignable to type 'Value[][]'.
        Type 'number' is not assignable to type 'Value[][]'.

[ahejlsberg]

Yet another type ordering issue. During inference in the call to flat we end up with two candidates: Value and Value[]. We pick whichever one is inferred first, which unfortunately differs. In an ideal world, inference would recognize that there's a pattern to Value[] | Value[][] and T[] | T[][] and always just infer Value for T, but that's not currently the case. The workaround is something like:

type ArrayArray<T> = Array<Array<T>>

declare function flat<T>(args: Array<T> | ArrayArray<T>): void;
type A = 1 | 2
declare const n: Array<A> | ArrayArray<A>
flat(n)

Here, the distinct type alias for array-of-arrays guides inference to only infer between instantiations of that type.

[jakebailey]

This function is something defined in lib.d.ts. It seems unfortunate that we'd have to define this special type to work around this inference case.

[jakebailey]

No, I'm a liar. flat in lib.d.ts does this differently without a union.

type FlatArray<Arr, Depth extends number> = {
    done: Arr;
    recur: Arr extends ReadonlyArray<infer InnerArr> ? FlatArray<InnerArr, [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20][Depth]>
        : Arr;
}[Depth extends -1 ? "done" : "recur"];

    /**
     * Returns a new array with all sub-array elements concatenated into it recursively up to the
     * specified depth.
     *
     * @param depth The maximum recursion depth
     */
    flat<A, D extends number = 1>(
        this: A,
        depth?: D,
    ): FlatArray<A, D>[];