Update Array.concat type signature to fix #6594

[LPGhatguy]

I wasn't sure whether I should commit the LKG changes with the source lib changes; there was another change that hasn't propagated to LKG yet (removal of WeakMap/WeakSet.clear) but I didn't commit it.

This should fix #6594.

[msftclas]

Hi @LPGhatguy, I'm your friendly neighborhood Microsoft Pull Request Bot (You can call me MSBOT). Thanks for your contribution!
You've already signed the contribution license agreement. Thanks!

The agreement was validated by Microsoft and real humans are currently evaluating your PR.

TTYL, MSBOT;

[DanielRosenwasser]

Can you undo the changes to lib?

[LPGhatguy]

Yeah; does that mean that the updates to lib are done all at once?

[DanielRosenwasser]

I think this overload can be removed, as @ahejlsberg mentioned on #6594 (comment).

[LPGhatguy]

Would that break any existing use of concat<T> by declaring it as a non-generic method?

[DanielRosenwasser]

I don't actually know why this was generic in the first place. Is there a reason T[] couldn't suffice?

Additionally, even if we decide not to drop this overload, this change is incorrect, since [1,2,3].concat([[1]],[[23]]) now works and still returns number[].

Give the following a try in the playground:

interface Array<T> {
    myConcat<U extends T[]>(...items: (U | U[])[]): T[];
    myConcat(...items: (T | T[])[]): T[];
}

var x = [1,2,3].myConcat([[23]])

[LPGhatguy]

Removing the generic line fixes that case, which makes me wonder whether the generic worked correctly before either.

I'll ditch it in the PR because I don't know why it would be in there either.

[ahejlsberg]

The generic overload should go. It was there for historical reasons (it was a workaround for an issue in the old compiler having to do with instantiations of Array<T> within Array<T> itself).

[LPGhatguy]

This new diff no longer has the generic overload; the following works in the playground:

interface Array<T> {
    myConcat(...items: (T | T[])[]): T[];
}

var x = [1,2,3].myConcat(23, [23]);
console.log(x);

While this does not, which is correct:

interface Array<T> {
    myConcat(...items: (T | T[])[]): T[];
}

var x = [1,2,3].myConcat([[23]]);
console.log(x);

[sandersn]

Sounds good to me. @ahejlsberg, can you confirm that it's in line with what you were thinking?

[ahejlsberg]

👍

[rkirov]

An interesting consequence of this change is the interplay with literal type freshness. Previously, the following was valid [{a: ''}].concat([{a: '', b: ''}]), but after the change it is not, because Object literal may only specify known properties. The old types implicitly allow for subtypes because of the type parameter U.