handle generic types in getArrayifiedType (microsoft#30606)

Author: weswigham

src/compiler/checker.ts

@@ -20443,7 +20443,7 @@ namespace ts {
 
         function getArrayifiedType(type: Type) {
             if (forEachType(type, t => !(t.flags & (TypeFlags.Any | TypeFlags.Instantiable) || isArrayType(t) || isTupleType(t)))) {
-                return createArrayType(getIndexTypeOfType(type, IndexKind.Number) || errorType);
+                return createArrayType(getIndexedAccessType(type, numberType));
             }
             return type;
         }

tests/baselines/reference/restTypeRetainsMappyness.errors.txt

@@ -0,0 +1,15 @@
+tests/cases/compiler/restTypeRetainsMappyness.ts(7,8): error TS2345: Argument of type 'Foo<T>[number][]' is not assignable to parameter of type 'Foo<T>'.
+
+
+==== tests/cases/compiler/restTypeRetainsMappyness.ts (1 errors) ====
+    type Foo<T extends any[]> = {
+        [P in keyof T]: T[P]
+    }
+    
+    function test<T extends any[]>(fn: (...args: Foo<T>) => void) {
+        const arr: Foo<T> = {} as any
+        fn(...arr) // Error: Argument of type 'any[]' is not assignable to parameter of type 'Foo<T>'
+           ~~~~~~
+!!! error TS2345: Argument of type 'Foo<T>[number][]' is not assignable to parameter of type 'Foo<T>'.
+    }
+    

tests/baselines/reference/restTypeRetainsMappyness.js

@@ -0,0 +1,16 @@
+//// [restTypeRetainsMappyness.ts]
+type Foo<T extends any[]> = {
+    [P in keyof T]: T[P]
+}
+
+function test<T extends any[]>(fn: (...args: Foo<T>) => void) {
+    const arr: Foo<T> = {} as any
+    fn(...arr) // Error: Argument of type 'any[]' is not assignable to parameter of type 'Foo<T>'
+}
+
+
+//// [restTypeRetainsMappyness.js]
+function test(fn) {
+    var arr = {};
+    fn.apply(void 0, arr); // Error: Argument of type 'any[]' is not assignable to parameter of type 'Foo<T>'
+}

tests/baselines/reference/restTypeRetainsMappyness.symbols

@@ -0,0 +1,30 @@
+=== tests/cases/compiler/restTypeRetainsMappyness.ts ===
+type Foo<T extends any[]> = {
+>Foo : Symbol(Foo, Decl(restTypeRetainsMappyness.ts, 0, 0))
+>T : Symbol(T, Decl(restTypeRetainsMappyness.ts, 0, 9))
+
+    [P in keyof T]: T[P]
+>P : Symbol(P, Decl(restTypeRetainsMappyness.ts, 1, 5))
+>T : Symbol(T, Decl(restTypeRetainsMappyness.ts, 0, 9))
+>T : Symbol(T, Decl(restTypeRetainsMappyness.ts, 0, 9))
+>P : Symbol(P, Decl(restTypeRetainsMappyness.ts, 1, 5))
+}
+
+function test<T extends any[]>(fn: (...args: Foo<T>) => void) {
+>test : Symbol(test, Decl(restTypeRetainsMappyness.ts, 2, 1))
+>T : Symbol(T, Decl(restTypeRetainsMappyness.ts, 4, 14))
+>fn : Symbol(fn, Decl(restTypeRetainsMappyness.ts, 4, 31))
+>args : Symbol(args, Decl(restTypeRetainsMappyness.ts, 4, 36))
+>Foo : Symbol(Foo, Decl(restTypeRetainsMappyness.ts, 0, 0))
+>T : Symbol(T, Decl(restTypeRetainsMappyness.ts, 4, 14))
+
+    const arr: Foo<T> = {} as any
+>arr : Symbol(arr, Decl(restTypeRetainsMappyness.ts, 5, 9))
+>Foo : Symbol(Foo, Decl(restTypeRetainsMappyness.ts, 0, 0))
+>T : Symbol(T, Decl(restTypeRetainsMappyness.ts, 4, 14))
+
+    fn(...arr) // Error: Argument of type 'any[]' is not assignable to parameter of type 'Foo<T>'
+>fn : Symbol(fn, Decl(restTypeRetainsMappyness.ts, 4, 31))
+>arr : Symbol(arr, Decl(restTypeRetainsMappyness.ts, 5, 9))
+}
+

tests/baselines/reference/restTypeRetainsMappyness.types

@@ -0,0 +1,24 @@
+=== tests/cases/compiler/restTypeRetainsMappyness.ts ===
+type Foo<T extends any[]> = {
+>Foo : Foo<T>
+
+    [P in keyof T]: T[P]
+}
+
+function test<T extends any[]>(fn: (...args: Foo<T>) => void) {
+>test : <T extends any[]>(fn: (...args: Foo<T>) => void) => void
+>fn : (...args: Foo<T>) => void
+>args : Foo<T>
+
+    const arr: Foo<T> = {} as any
+>arr : Foo<T>
+>{} as any : any
+>{} : {}
+
+    fn(...arr) // Error: Argument of type 'any[]' is not assignable to parameter of type 'Foo<T>'
+>fn(...arr) : void
+>fn : (...args: Foo<T>) => void
+>...arr : any
+>arr : Foo<T>
+}
+

tests/cases/compiler/restTypeRetainsMappyness.ts

@@ -0,0 +1,8 @@
+type Foo<T extends any[]> = {
+    [P in keyof T]: T[P]
+}
+
+function test<T extends any[]>(fn: (...args: Foo<T>) => void) {
+    const arr: Foo<T> = {} as any
+    fn(...arr) // Error: Argument of type 'any[]' is not assignable to parameter of type 'Foo<T>'
+}