Mapped type applied to array type produces wrong `toString`, `filter`, etc type

[gabritto]

🔎 Search Terms

toString mapped type

🕗 Version & Regression Information

• This changed between versions 4.6 and 4.7

⏯ Playground Link

https://www.typescriptlang.org/play?ts=5.4.0-dev.20240110#code/C4TwDgpgBAsghmMIA8AVKEAewIDsAmAzlAK64DWuA9gO64DaAugHxQC8UA3lPQNJQBLXFHIQQVAGZR0cYr0YAuaX0ZQAvgG4AsAChQkKADkqwAIIAnc3BDtYCJMlwkAtgCMI5ps207d+CADGADZw5tASZAHAAlTC+FQWViAAysAkEhIAFJhKZJS0DIwAlEoAblQC+D7+waHQAbGEwFA5RiaJ1tUJltap6VmYRRpAA

💻 Code

type Mappy<T extends unknown[]> = { [K in keyof T as K]: T[K] };
type NotArray = Mappy<number[]>;

declare function doArrayStuff(x: unknown[]): void;
declare const x: NotArray;
doArrayStuff(x); // Error

🙁 Actual behavior

Error on doArrayStuff(x):
Argument of type 'Mappy<number[]>' is not assignable to parameter of type 'unknown[]'.
Types of property 'toString' are incompatible.
Type 'number' is not assignable to type '() => string'

🙂 Expected behavior

No error, type of x's toString is () => string.

Additional information about the issue

No response

[DanielRosenwasser]

This changed between versions 4.6 and 4.7

These say they were scheduled for 4.5, but I wonder if this is related to #46218 and #46169.

[gabritto]

Bisected to #48837

[gabritto]

This happens because, as of #48837, whenever we see a mapped type like type Mappy<T extends unknown[]> = { [K in keyof T as K]: T[K] } where the modifier type (T) is an array or tuple, we add a numeric constraint to K in the template type. So the mapped type is internally represented as something like this:
type Mappy<T extends unknown[]> = { [K in keyof T as K]: T[K & (number | ${number})] }.
When we try to get the type of property toString of type Mappy<number[]>, what we do is instantiate the mapped type's template type, T[K & (number | ${number})], with T = number[] and K = "toString". So T[K & (number | ${number})] becomes (number[])["toString" & (number | ${number})], which resolves to (number[])[never]. Type number[] has an index signature mapping numbers to numbers, so (number[])[never] resolves to number via this index signature.
The same happens for the other array methods and they all end up having type number.

This problem is not present when you remove the as K clause in the mapped type, i.e. because then we resolve the mapped type Mappy<number[]> in a special way that directly creates an array type as a result, instead of the normal instantiation process described above.

#55774 would fix this.