ReadonlyArray with rest parameters

[NN---]

I expect all three functions to be compiled successfully.
TypeScript doesn't allow using ReadonlyArray although it is the same as Array but readonly.

function f(...rest: any[]) { }
function g(...rest: Array<any>) { }
function h(...rest: ReadonlyArray<any>) { }

[NN---]

This limitation makes harder to use tslint-immutable package.
https://www.npmjs.com/package/tslint-immutable

[adieuadieu]

Is the following the right place to start with implementing a fix?

https://github.com/Microsoft/TypeScript/blob/14bd0a2d5678d89c474443f02841654c7d014b40/src/compiler/utilities.ts#L930-L940

[mhegazy]

There are a few places where we make an assumption about rest params being the globalArrayType, we will need to look at them all and fix them. one place is for example any use of isArrayType with rest params.

[mhegazy]

Union and intersections are another example (See #23440).

function dist(x1: number, y1: number, x2: number, y2: number): number
function dist(point1: point, point2: point): number
function dist(...args: number[] | point[]): number {
  // function body
}

[alexander-alvarez]

I think I'm hitting the same issue when I do something like this:

declare interface R {
    a: [string, number],
    b: [boolean]
}

declare function on<T extends keyof R, K extends R[T]>(val: T, listener: (...args: K) => void): void;
// rest parameter must be array type ^ in ...args


on('b', (a) => {
})

as a workaround I've had to not use the splat args, and overload the method for each arity

[robbiespeed]

This is also an issue for conditional types inside generic class methods

class Foo <T> {
    bar(...args: T extends number ? number[] : string[]): void { // A rest parameter must be of an array type.
    }
}

[sam-s4s]

Yeah I've just run into this issue...

remove(...items: (M[] | number[])) {}

The above code should work, but does not :(

[McPrescott]

There is a temporary work around for some of the issues mentioned here, specifically the union types, until problem is resolved

type F1 = (...args: number[] | string[]) => any; // Throws an error
type Fof<T extends any[], R> = (...args: T) => R;
type F2 = Fof<number[] | string[], any>; // Compiles without error

It's not clear to me why this fix works. As you can see in the screenshot below, the type of F2 is (...args: number[] | string[]) => any even though that type is apparently an error.