Check for array types when instantiating mapped type constraints with any

src/compiler/checker.ts

@@ -16515,7 +16515,8 @@ namespace ts {
                     return mapTypeWithAlias(getReducedType(mappedTypeVariable), t => {
                         if (t.flags & (TypeFlags.AnyOrUnknown | TypeFlags.InstantiableNonPrimitive | TypeFlags.Object | TypeFlags.Intersection) && t !== wildcardType && !isErrorType(t)) {
                             if (!type.declaration.nameType) {
-                                if (isArrayType(t)) {
+                                let constraint;
+                                if (isArrayType(t) || (t.flags & TypeFlags.Any) && (constraint = getConstraintOfTypeParameter(typeVariable)) && everyType(constraint, or(isArrayType, isTupleType))) {
                                     return instantiateMappedArrayType(t, type, prependTypeMapping(typeVariable, t, mapper));
                                 }
                                 if (isGenericTupleType(t)) {

tests/baselines/reference/mappedTypeWithAny.errors.txt

@@ -1,7 +1,8 @@
 tests/cases/conformance/types/mapped/mappedTypeWithAny.ts(23,16): error TS2339: Property 'notAValue' does not exist on type 'Data'.
+tests/cases/conformance/types/mapped/mappedTypeWithAny.ts(36,5): error TS2740: Type 'Objectish<any>' is missing the following properties from type 'any[]': length, pop, push, concat, and 16 more.
 
 
-==== tests/cases/conformance/types/mapped/mappedTypeWithAny.ts (1 errors) ====
+==== tests/cases/conformance/types/mapped/mappedTypeWithAny.ts (2 errors) ====
     type Item = { value: string };
     type ItemMap<T> = { [P in keyof T]: Item };
 
@@ -28,4 +29,21 @@ tests/cases/conformance/types/mapped/mappedTypeWithAny.ts(23,16): error TS2339:
                    ~~~~~~~~~
 !!! error TS2339: Property 'notAValue' does not exist on type 'Data'.
     }
-
+
+    // Issue #46169.
+    // We want mapped types whose constraint is `keyof T` to
+    // map over `any` differently, depending on whether `T`
+    // is constrained to an array-like type.
+    type Arrayish<T extends unknown[]> = { [K in keyof T]: T[K] };
+    type Objectish<T extends unknown> = { [K in keyof T]: T[K] };
+
+    function bar(arrayish: Arrayish<any>, objectish: Objectish<any>) {
+        let arr: any[];
+        arr = arrayish;
+        arr = objectish;
+        ~~~
+!!! error TS2740: Type 'Objectish<any>' is missing the following properties from type 'any[]': length, pop, push, concat, and 16 more.
+    }
+
+    declare function stringifyArray<T extends readonly any[]>(arr: T): { -readonly [K in keyof T]: string };
+    let abc: any[] = stringifyArray(void 0 as any);

tests/baselines/reference/mappedTypeWithAny.js

@@ -23,14 +23,35 @@ for (let id in z) {
   let data = z[id];
   let x = data.notAValue;  // Error
 }
-
+
+// Issue #46169.
+// We want mapped types whose constraint is `keyof T` to
+// map over `any` differently, depending on whether `T`
+// is constrained to an array-like type.
+type Arrayish<T extends unknown[]> = { [K in keyof T]: T[K] };
+type Objectish<T extends unknown> = { [K in keyof T]: T[K] };
+
+function bar(arrayish: Arrayish<any>, objectish: Objectish<any>) {
+    let arr: any[];
+    arr = arrayish;
+    arr = objectish;
+}
+
+declare function stringifyArray<T extends readonly any[]>(arr: T): { -readonly [K in keyof T]: string };
+let abc: any[] = stringifyArray(void 0 as any);
 
 //// [mappedTypeWithAny.js]
 "use strict";
 for (var id in z) {
     var data = z[id];
     var x = data.notAValue; // Error
 }
+function bar(arrayish, objectish) {
+    var arr;
+    arr = arrayish;
+    arr = objectish;
+}
+var abc = stringifyArray(void 0);
 
 
 //// [mappedTypeWithAny.d.ts]
@@ -58,3 +79,14 @@ declare type StrictDataMap<T> = {
     [P in keyof T]: Data;
 };
 declare let z: StrictDataMap<any>;
+declare type Arrayish<T extends unknown[]> = {
+    [K in keyof T]: T[K];
+};
+declare type Objectish<T extends unknown> = {
+    [K in keyof T]: T[K];
+};
+declare function bar(arrayish: Arrayish<any>, objectish: Objectish<any>): void;
+declare function stringifyArray<T extends readonly any[]>(arr: T): {
+    -readonly [K in keyof T]: string;
+};
+declare let abc: any[];

tests/baselines/reference/mappedTypeWithAny.symbols

@@ -69,3 +69,54 @@ for (let id in z) {
 >data : Symbol(data, Decl(mappedTypeWithAny.ts, 21, 5))
 }
 
+// Issue #46169.
+// We want mapped types whose constraint is `keyof T` to
+// map over `any` differently, depending on whether `T`
+// is constrained to an array-like type.
+type Arrayish<T extends unknown[]> = { [K in keyof T]: T[K] };
+>Arrayish : Symbol(Arrayish, Decl(mappedTypeWithAny.ts, 23, 1))
+>T : Symbol(T, Decl(mappedTypeWithAny.ts, 29, 14))
+>K : Symbol(K, Decl(mappedTypeWithAny.ts, 29, 40))
+>T : Symbol(T, Decl(mappedTypeWithAny.ts, 29, 14))
+>T : Symbol(T, Decl(mappedTypeWithAny.ts, 29, 14))
+>K : Symbol(K, Decl(mappedTypeWithAny.ts, 29, 40))
+
+type Objectish<T extends unknown> = { [K in keyof T]: T[K] };
+>Objectish : Symbol(Objectish, Decl(mappedTypeWithAny.ts, 29, 62))
+>T : Symbol(T, Decl(mappedTypeWithAny.ts, 30, 15))
+>K : Symbol(K, Decl(mappedTypeWithAny.ts, 30, 39))
+>T : Symbol(T, Decl(mappedTypeWithAny.ts, 30, 15))
+>T : Symbol(T, Decl(mappedTypeWithAny.ts, 30, 15))
+>K : Symbol(K, Decl(mappedTypeWithAny.ts, 30, 39))
+
+function bar(arrayish: Arrayish<any>, objectish: Objectish<any>) {
+>bar : Symbol(bar, Decl(mappedTypeWithAny.ts, 30, 61))
+>arrayish : Symbol(arrayish, Decl(mappedTypeWithAny.ts, 32, 13))
+>Arrayish : Symbol(Arrayish, Decl(mappedTypeWithAny.ts, 23, 1))
+>objectish : Symbol(objectish, Decl(mappedTypeWithAny.ts, 32, 37))
+>Objectish : Symbol(Objectish, Decl(mappedTypeWithAny.ts, 29, 62))
+
+    let arr: any[];
+>arr : Symbol(arr, Decl(mappedTypeWithAny.ts, 33, 7))
+
+    arr = arrayish;
+>arr : Symbol(arr, Decl(mappedTypeWithAny.ts, 33, 7))
+>arrayish : Symbol(arrayish, Decl(mappedTypeWithAny.ts, 32, 13))
+
+    arr = objectish;
+>arr : Symbol(arr, Decl(mappedTypeWithAny.ts, 33, 7))
+>objectish : Symbol(objectish, Decl(mappedTypeWithAny.ts, 32, 37))
+}
+
+declare function stringifyArray<T extends readonly any[]>(arr: T): { -readonly [K in keyof T]: string };
+>stringifyArray : Symbol(stringifyArray, Decl(mappedTypeWithAny.ts, 36, 1))
+>T : Symbol(T, Decl(mappedTypeWithAny.ts, 38, 32))
+>arr : Symbol(arr, Decl(mappedTypeWithAny.ts, 38, 58))
+>T : Symbol(T, Decl(mappedTypeWithAny.ts, 38, 32))
+>K : Symbol(K, Decl(mappedTypeWithAny.ts, 38, 80))
+>T : Symbol(T, Decl(mappedTypeWithAny.ts, 38, 32))
+
+let abc: any[] = stringifyArray(void 0 as any);
+>abc : Symbol(abc, Decl(mappedTypeWithAny.ts, 39, 3))
+>stringifyArray : Symbol(stringifyArray, Decl(mappedTypeWithAny.ts, 36, 1))
+

tests/baselines/reference/mappedTypeWithAny.types

@@ -56,3 +56,44 @@ for (let id in z) {
 >notAValue : any
 }
 
+// Issue #46169.
+// We want mapped types whose constraint is `keyof T` to
+// map over `any` differently, depending on whether `T`
+// is constrained to an array-like type.
+type Arrayish<T extends unknown[]> = { [K in keyof T]: T[K] };
+>Arrayish : Arrayish<T>
+
+type Objectish<T extends unknown> = { [K in keyof T]: T[K] };
+>Objectish : Objectish<T>
+
+function bar(arrayish: Arrayish<any>, objectish: Objectish<any>) {
+>bar : (arrayish: Arrayish<any>, objectish: Objectish<any>) => void
+>arrayish : any[]
+>objectish : Objectish<any>
+
+    let arr: any[];
+>arr : any[]
+
+    arr = arrayish;
+>arr = arrayish : any[]
+>arr : any[]
+>arrayish : any[]
+
+    arr = objectish;
+>arr = objectish : Objectish<any>
+>arr : any[]
+>objectish : Objectish<any>
+}
+
+declare function stringifyArray<T extends readonly any[]>(arr: T): { -readonly [K in keyof T]: string };
+>stringifyArray : <T extends readonly any[]>(arr: T) => { -readonly [K in keyof T]: string; }
+>arr : T
+
+let abc: any[] = stringifyArray(void 0 as any);
+>abc : any[]
+>stringifyArray(void 0 as any) : string[]
+>stringifyArray : <T extends readonly any[]>(arr: T) => { -readonly [K in keyof T]: string; }
+>void 0 as any : any
+>void 0 : undefined
+>0 : 0
+

tests/baselines/reference/promiseAllOnAny01.symbols

@@ -0,0 +1,19 @@
+=== tests/cases/compiler/promiseAllOnAny01.ts ===
+async function foo(x: any) {
+>foo : Symbol(foo, Decl(promiseAllOnAny01.ts, 0, 0))
+>x : Symbol(x, Decl(promiseAllOnAny01.ts, 0, 19))
+
+    let abc = await Promise.all(x);
+>abc : Symbol(abc, Decl(promiseAllOnAny01.ts, 1, 7))
+>Promise.all : Symbol(PromiseConstructor.all, Decl(lib.es2015.promise.d.ts, --, --))
+>Promise : Symbol(Promise, Decl(lib.es5.d.ts, --, --), Decl(lib.es2015.promise.d.ts, --, --))
+>all : Symbol(PromiseConstructor.all, Decl(lib.es2015.promise.d.ts, --, --))
+>x : Symbol(x, Decl(promiseAllOnAny01.ts, 0, 19))
+
+    let result: any[] = abc;
+>result : Symbol(result, Decl(promiseAllOnAny01.ts, 2, 7))
+>abc : Symbol(abc, Decl(promiseAllOnAny01.ts, 1, 7))
+
+    return result;
+>result : Symbol(result, Decl(promiseAllOnAny01.ts, 2, 7))
+}

tests/baselines/reference/promiseAllOnAny01.types

@@ -0,0 +1,21 @@
+=== tests/cases/compiler/promiseAllOnAny01.ts ===
+async function foo(x: any) {
+>foo : (x: any) => Promise<any[]>
+>x : any
+
+    let abc = await Promise.all(x);
+>abc : any[]
+>await Promise.all(x) : any[]
+>Promise.all(x) : Promise<any[]>
+>Promise.all : <T extends readonly unknown[] | []>(values: T) => Promise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>
+>Promise : PromiseConstructor
+>all : <T extends readonly unknown[] | []>(values: T) => Promise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>
+>x : any
+
+    let result: any[] = abc;
+>result : any[]
+>abc : any[]
+
+    return result;
+>result : any[]
+}

tests/cases/compiler/promiseAllOnAny01.ts

@@ -0,0 +1,8 @@
+// @noEmit: true
+// @lib: es5,es2015.promise
+
+async function foo(x: any) {
+    let abc = await Promise.all(x);
+    let result: any[] = abc;
+    return result;
+}

tests/cases/conformance/types/mapped/mappedTypeWithAny.ts

@@ -25,3 +25,19 @@ for (let id in z) {
   let data = z[id];
   let x = data.notAValue;  // Error
 }
+
+// Issue #46169.
+// We want mapped types whose constraint is `keyof T` to
+// map over `any` differently, depending on whether `T`
+// is constrained to an array-like type.
+type Arrayish<T extends unknown[]> = { [K in keyof T]: T[K] };
+type Objectish<T extends unknown> = { [K in keyof T]: T[K] };
+
+function bar(arrayish: Arrayish<any>, objectish: Objectish<any>) {
+    let arr: any[];
+    arr = arrayish;
+    arr = objectish;
+}
+
+declare function stringifyArray<T extends readonly any[]>(arr: T): { -readonly [K in keyof T]: string };
+let abc: any[] = stringifyArray(void 0 as any);