Better typings for Array.concat()

Author: jablko

src/lib/es5.d.ts

@@ -1080,12 +1080,12 @@ interface ReadonlyArray<T> {
      * Combines two or more arrays.
      * @param items Additional items to add to the end of array1.
      */
-    concat(...items: ConcatArray<T>[]): T[];
+    concat<U>(...items: ConcatArray<U>[]): (T | U)[];
     /**
      * Combines two or more arrays.
      * @param items Additional items to add to the end of array1.
      */
-    concat(...items: (T | ConcatArray<T>)[]): T[];
+    concat<U>(...items: (U | ConcatArray<U>)[]): (T | U)[];
     /**
      * Adds all the elements of an array separated by the specified separator string.
      * @param separator A string used to separate one element of an array from the next in the resulting String. If omitted, the array elements are separated with a comma.
@@ -1208,12 +1208,12 @@ interface Array<T> {
      * Combines two or more arrays.
      * @param items Additional items to add to the end of array1.
      */
-    concat(...items: ConcatArray<T>[]): T[];
+    concat<U>(...items: ConcatArray<U>[]): (T | U)[];
     /**
      * Combines two or more arrays.
      * @param items Additional items to add to the end of array1.
      */
-    concat(...items: (T | ConcatArray<T>)[]): T[];
+    concat<U>(...items: (U | ConcatArray<U>)[]): (T | U)[];
     /**
      * Adds all the elements of an array separated by the specified separator string.
      * @param separator A string used to separate one element of an array from the next in the resulting String. If omitted, the array elements are separated with a comma.

tests/baselines/reference/arrayConcat2.types

@@ -5,17 +5,17 @@ var a: string[] = [];
 
 a.concat("hello", 'world');
 >a.concat("hello", 'world') : string[]
->a.concat : { (...items: ConcatArray<string>[]): string[]; (...items: (string | ConcatArray<string>)[]): string[]; }
+>a.concat : { <U>(...items: ConcatArray<U>[]): (string | U)[]; <U>(...items: (U | ConcatArray<U>)[]): (string | U)[]; }
 >a : string[]
->concat : { (...items: ConcatArray<string>[]): string[]; (...items: (string | ConcatArray<string>)[]): string[]; }
+>concat : { <U>(...items: ConcatArray<U>[]): (string | U)[]; <U>(...items: (U | ConcatArray<U>)[]): (string | U)[]; }
 >"hello" : "hello"
 >'world' : "world"
 
 a.concat('Hello');
 >a.concat('Hello') : string[]
->a.concat : { (...items: ConcatArray<string>[]): string[]; (...items: (string | ConcatArray<string>)[]): string[]; }
+>a.concat : { <U>(...items: ConcatArray<U>[]): (string | U)[]; <U>(...items: (U | ConcatArray<U>)[]): (string | U)[]; }
 >a : string[]
->concat : { (...items: ConcatArray<string>[]): string[]; (...items: (string | ConcatArray<string>)[]): string[]; }
+>concat : { <U>(...items: ConcatArray<U>[]): (string | U)[]; <U>(...items: (U | ConcatArray<U>)[]): (string | U)[]; }
 >'Hello' : "Hello"
 
 var b = new Array<string>();
@@ -25,8 +25,8 @@ var b = new Array<string>();
 
 b.concat('hello');
 >b.concat('hello') : string[]
->b.concat : { (...items: ConcatArray<string>[]): string[]; (...items: (string | ConcatArray<string>)[]): string[]; }
+>b.concat : { <U>(...items: ConcatArray<U>[]): (string | U)[]; <U>(...items: (U | ConcatArray<U>)[]): (string | U)[]; }
 >b : string[]
->concat : { (...items: ConcatArray<string>[]): string[]; (...items: (string | ConcatArray<string>)[]): string[]; }
+>concat : { <U>(...items: ConcatArray<U>[]): (string | U)[]; <U>(...items: (U | ConcatArray<U>)[]): (string | U)[]; }
 >'hello' : "hello"
 

tests/baselines/reference/arrayConcat3.types

@@ -10,10 +10,10 @@ function doStuff<T extends object, T1 extends T>(a: Array<Fn<T>>, b: Array<Fn<T1
 >b : Fn<T1>[]
 
     b.concat(a);
->b.concat(a) : Fn<T1>[]
->b.concat : { (...items: ConcatArray<Fn<T1>>[]): Fn<T1>[]; (...items: (Fn<T1> | ConcatArray<Fn<T1>>)[]): Fn<T1>[]; }
+>b.concat(a) : (Fn<T> | Fn<T1>)[]
+>b.concat : { <U>(...items: ConcatArray<U>[]): (Fn<T1> | U)[]; <U>(...items: (U | ConcatArray<U>)[]): (Fn<T1> | U)[]; }
 >b : Fn<T1>[]
->concat : { (...items: ConcatArray<Fn<T1>>[]): Fn<T1>[]; (...items: (Fn<T1> | ConcatArray<Fn<T1>>)[]): Fn<T1>[]; }
+>concat : { <U>(...items: ConcatArray<U>[]): (Fn<T1> | U)[]; <U>(...items: (U | ConcatArray<U>)[]): (Fn<T1> | U)[]; }
 >a : Fn<T>[]
 }
 

tests/baselines/reference/arrayConcatMap.types

@@ -4,9 +4,9 @@ var x = [].concat([{ a: 1 }], [{ a: 2 }])
 >[].concat([{ a: 1 }], [{ a: 2 }])          .map(b => b.a) : any[]
 >[].concat([{ a: 1 }], [{ a: 2 }])          .map : <U>(callbackfn: (value: any, index: number, array: any[]) => U, thisArg?: any) => U[]
 >[].concat([{ a: 1 }], [{ a: 2 }]) : any[]
->[].concat : { (...items: ConcatArray<any>[]): any[]; (...items: any[]): any[]; }
+>[].concat : { <U>(...items: ConcatArray<U>[]): any[]; <U>(...items: (U | ConcatArray<U>)[]): any[]; }
 >[] : undefined[]
->concat : { (...items: ConcatArray<any>[]): any[]; (...items: any[]): any[]; }
+>concat : { <U>(...items: ConcatArray<U>[]): any[]; <U>(...items: (U | ConcatArray<U>)[]): any[]; }
 >[{ a: 1 }] : { a: number; }[]
 >{ a: 1 } : { a: number; }
 >a : number

tests/baselines/reference/arrayOfSubtypeIsAssignableToReadonlyArray.errors.txt

@@ -1,7 +1,7 @@
 tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts(13,1): error TS2322: Type 'A[]' is not assignable to type 'readonly B[]'.
   Property 'b' is missing in type 'A' but required in type 'B'.
 tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts(18,1): error TS2322: Type 'C<A>' is not assignable to type 'readonly B[]'.
-  The types returned by 'concat(...)' are incompatible between these types.
+  The types returned by 'slice(...)' are incompatible between these types.
     Type 'A[]' is not assignable to type 'B[]'.
       Type 'A' is not assignable to type 'B'.
 
@@ -31,7 +31,7 @@ tests/cases/compiler/arrayOfSubtypeIsAssignableToReadonlyArray.ts(18,1): error T
     rrb = cra; // error: 'A' is not assignable to 'B'
     ~~~
 !!! error TS2322: Type 'C<A>' is not assignable to type 'readonly B[]'.
-!!! error TS2322:   The types returned by 'concat(...)' are incompatible between these types.
+!!! error TS2322:   The types returned by 'slice(...)' are incompatible between these types.
 !!! error TS2322:     Type 'A[]' is not assignable to type 'B[]'.
 !!! error TS2322:       Type 'A' is not assignable to type 'B'.
 

tests/baselines/reference/concatError.types

@@ -15,19 +15,19 @@ fa = fa.concat([0]);
 >fa = fa.concat([0]) : number[]
 >fa : number[]
 >fa.concat([0]) : number[]
->fa.concat : { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }
+>fa.concat : { <U>(...items: ConcatArray<U>[]): (number | U)[]; <U>(...items: (U | ConcatArray<U>)[]): (number | U)[]; }
 >fa : number[]
->concat : { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }
+>concat : { <U>(...items: ConcatArray<U>[]): (number | U)[]; <U>(...items: (U | ConcatArray<U>)[]): (number | U)[]; }
 >[0] : number[]
 >0 : 0
 
 fa = fa.concat(0);
 >fa = fa.concat(0) : number[]
 >fa : number[]
 >fa.concat(0) : number[]
->fa.concat : { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }
+>fa.concat : { <U>(...items: ConcatArray<U>[]): (number | U)[]; <U>(...items: (U | ConcatArray<U>)[]): (number | U)[]; }
 >fa : number[]
->concat : { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }
+>concat : { <U>(...items: ConcatArray<U>[]): (number | U)[]; <U>(...items: (U | ConcatArray<U>)[]): (number | U)[]; }
 >0 : 0
 
 

tests/baselines/reference/concatTuples.types

@@ -10,9 +10,9 @@ ijs = ijs.concat([[3, 4], [5, 6]]);
 >ijs = ijs.concat([[3, 4], [5, 6]]) : [number, number][]
 >ijs : [number, number][]
 >ijs.concat([[3, 4], [5, 6]]) : [number, number][]
->ijs.concat : { (...items: ConcatArray<[number, number]>[]): [number, number][]; (...items: ([number, number] | ConcatArray<[number, number]>)[]): [number, number][]; }
+>ijs.concat : { <U>(...items: ConcatArray<U>[]): ([number, number] | U)[]; <U>(...items: (U | ConcatArray<U>)[]): ([number, number] | U)[]; }
 >ijs : [number, number][]
->concat : { (...items: ConcatArray<[number, number]>[]): [number, number][]; (...items: ([number, number] | ConcatArray<[number, number]>)[]): [number, number][]; }
+>concat : { <U>(...items: ConcatArray<U>[]): ([number, number] | U)[]; <U>(...items: (U | ConcatArray<U>)[]): ([number, number] | U)[]; }
 >[[3, 4], [5, 6]] : [number, number][]
 >[3, 4] : [number, number]
 >3 : 3

tests/baselines/reference/contextualExpressionTypecheckingDoesntBlowStack.types

@@ -69,15 +69,15 @@ export default class Operation {
 
                 // Commenting out this line will fix the problem.
                 result = (result || []).concat(innerResult);
->result = (result || []).concat(innerResult) : IValidationError[]
+>result = (result || []).concat(innerResult) : any[]
 >result : IValidationError[] | null
->(result || []).concat(innerResult) : IValidationError[]
->(result || []).concat : { (...items: ConcatArray<IValidationError>[]): IValidationError[]; (...items: (IValidationError | ConcatArray<IValidationError>)[]): IValidationError[]; }
+>(result || []).concat(innerResult) : any[]
+>(result || []).concat : { <U>(...items: ConcatArray<U>[]): (IValidationError | U)[]; <U>(...items: (U | ConcatArray<U>)[]): (IValidationError | U)[]; }
 >(result || []) : IValidationError[]
 >result || [] : IValidationError[]
 >result : IValidationError[] | null
 >[] : never[]
->concat : { (...items: ConcatArray<IValidationError>[]): IValidationError[]; (...items: (IValidationError | ConcatArray<IValidationError>)[]): IValidationError[]; }
+>concat : { <U>(...items: ConcatArray<U>[]): (IValidationError | U)[]; <U>(...items: (U | ConcatArray<U>)[]): (IValidationError | U)[]; }
 >innerResult : any
             }
         }

tests/baselines/reference/destructuringTuple.errors.txt

@@ -1,12 +1,13 @@
-tests/cases/compiler/destructuringTuple.ts(11,8): error TS2493: Tuple type '[]' of length '0' has no element at index '0'.
-tests/cases/compiler/destructuringTuple.ts(11,60): error TS2769: No overload matches this call.
-  Overload 1 of 2, '(...items: ConcatArray<never>[]): never[]', gave the following error.
-    Argument of type 'number' is not assignable to parameter of type 'ConcatArray<never>'.
-  Overload 2 of 2, '(...items: ConcatArray<never>[]): never[]', gave the following error.
-    Argument of type 'number' is not assignable to parameter of type 'ConcatArray<never>'.
+tests/cases/compiler/destructuringTuple.ts(11,48): error TS2769: No overload matches this call.
+  Overload 1 of 3, '(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number', gave the following error.
+    Type 'number[]' is not assignable to type 'number'.
+  Overload 2 of 3, '(callbackfn: (previousValue: [], currentValue: number, currentIndex: number, array: number[]) => [], initialValue: []): []', gave the following error.
+    Type 'number[]' is not assignable to type '[]'.
+      Types of property 'length' are incompatible.
+        Type 'number' is not assignable to type '0'.
 
 
-==== tests/cases/compiler/destructuringTuple.ts (2 errors) ====
+==== tests/cases/compiler/destructuringTuple.ts (1 errors) ====
     declare var tuple: [boolean, number, ...string[]];
 
     const [a, b, c, ...rest] = tuple;
@@ -18,14 +19,16 @@ tests/cases/compiler/destructuringTuple.ts(11,60): error TS2769: No overload mat
     // Repros from #32140
 
     const [oops1] = [1, 2, 3].reduce((accu, el) => accu.concat(el), []);
-           ~~~~~
-!!! error TS2493: Tuple type '[]' of length '0' has no element at index '0'.
-                                                               ~~
+                                                   ~~~~~~~~~~~~~~~
 !!! error TS2769: No overload matches this call.
-!!! error TS2769:   Overload 1 of 2, '(...items: ConcatArray<never>[]): never[]', gave the following error.
-!!! error TS2769:     Argument of type 'number' is not assignable to parameter of type 'ConcatArray<never>'.
-!!! error TS2769:   Overload 2 of 2, '(...items: ConcatArray<never>[]): never[]', gave the following error.
-!!! error TS2769:     Argument of type 'number' is not assignable to parameter of type 'ConcatArray<never>'.
+!!! error TS2769:   Overload 1 of 3, '(callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number', gave the following error.
+!!! error TS2769:     Type 'number[]' is not assignable to type 'number'.
+!!! error TS2769:   Overload 2 of 3, '(callbackfn: (previousValue: [], currentValue: number, currentIndex: number, array: number[]) => [], initialValue: []): []', gave the following error.
+!!! error TS2769:     Type 'number[]' is not assignable to type '[]'.
+!!! error TS2769:       Types of property 'length' are incompatible.
+!!! error TS2769:         Type 'number' is not assignable to type '0'.
+!!! related TS6502 /.ts/lib.es5.d.ts:1338:24: The expected type comes from the return type of this signature.
+!!! related TS6502 /.ts/lib.es5.d.ts:1344:27: The expected type comes from the return type of this signature.
 
     const [oops2] = [1, 2, 3].reduce((acc: number[], e) => acc.concat(e), []);
 

tests/baselines/reference/destructuringTuple.types

@@ -23,23 +23,23 @@ declare var receiver: typeof tuple;
 // Repros from #32140
 
 const [oops1] = [1, 2, 3].reduce((accu, el) => accu.concat(el), []);
->oops1 : undefined
->[1, 2, 3].reduce((accu, el) => accu.concat(el), []) : []
+>oops1 : any
+>[1, 2, 3].reduce((accu, el) => accu.concat(el), []) : any
 >[1, 2, 3].reduce : { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }
 >[1, 2, 3] : number[]
 >1 : 1
 >2 : 2
 >3 : 3
 >reduce : { (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number): number; (callbackfn: (previousValue: number, currentValue: number, currentIndex: number, array: number[]) => number, initialValue: number): number; <U>(callbackfn: (previousValue: U, currentValue: number, currentIndex: number, array: number[]) => U, initialValue: U): U; }
->(accu, el) => accu.concat(el) : (accu: [], el: number) => any
+>(accu, el) => accu.concat(el) : (accu: [], el: number) => number[]
 >accu : []
 >el : number
->accu.concat(el) : any
->accu.concat : { (...items: ConcatArray<never>[]): never[]; (...items: ConcatArray<never>[]): never[]; }
+>accu.concat(el) : number[]
+>accu.concat : { <U>(...items: ConcatArray<U>[]): U[]; <U>(...items: (U | ConcatArray<U>)[]): U[]; }
 >accu : []
->concat : { (...items: ConcatArray<never>[]): never[]; (...items: ConcatArray<never>[]): never[]; }
+>concat : { <U>(...items: ConcatArray<U>[]): U[]; <U>(...items: (U | ConcatArray<U>)[]): U[]; }
 >el : number
->[] : []
+>[] : never[]
 
 const [oops2] = [1, 2, 3].reduce((acc: number[], e) => acc.concat(e), []);
 >oops2 : number
@@ -54,9 +54,9 @@ const [oops2] = [1, 2, 3].reduce((acc: number[], e) => acc.concat(e), []);
 >acc : number[]
 >e : number
 >acc.concat(e) : number[]
->acc.concat : { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }
+>acc.concat : { <U>(...items: ConcatArray<U>[]): (number | U)[]; <U>(...items: (U | ConcatArray<U>)[]): (number | U)[]; }
 >acc : number[]
->concat : { (...items: ConcatArray<number>[]): number[]; (...items: (number | ConcatArray<number>)[]): number[]; }
+>concat : { <U>(...items: ConcatArray<U>[]): (number | U)[]; <U>(...items: (U | ConcatArray<U>)[]): (number | U)[]; }
 >e : number
 >[] : never[]
 

tests/baselines/reference/emitSkipsThisWithRestParameter.types

@@ -18,10 +18,10 @@ function rebase(fn: (base: any, ...args: any[]) => any): (...args: any[]) => any
 >apply : (this: Function, thisArg: any, argArray?: any) => any
 >this : any
 >[ this ].concat(args) : any[]
->[ this ].concat : { (...items: ConcatArray<any>[]): any[]; (...items: any[]): any[]; }
+>[ this ].concat : { <U>(...items: ConcatArray<U>[]): any[]; <U>(...items: (U | ConcatArray<U>)[]): any[]; }
 >[ this ] : any[]
 >this : any
->concat : { (...items: ConcatArray<any>[]): any[]; (...items: any[]): any[]; }
+>concat : { <U>(...items: ConcatArray<U>[]): any[]; <U>(...items: (U | ConcatArray<U>)[]): any[]; }
 >args : any[]
 
     };

tests/baselines/reference/intersectionTypeInference3.types

@@ -24,13 +24,13 @@ declare const b: Set<A>;
 const c1 = Array.from(a).concat(Array.from(b));
 >c1 : Nominal<"A", string>[]
 >Array.from(a).concat(Array.from(b)) : Nominal<"A", string>[]
->Array.from(a).concat : { (...items: ConcatArray<Nominal<"A", string>>[]): Nominal<"A", string>[]; (...items: (Nominal<"A", string> | ConcatArray<Nominal<"A", string>>)[]): Nominal<"A", string>[]; }
+>Array.from(a).concat : { <U>(...items: ConcatArray<U>[]): (Nominal<"A", string> | U)[]; <U>(...items: (U | ConcatArray<U>)[]): (Nominal<"A", string> | U)[]; }
 >Array.from(a) : Nominal<"A", string>[]
 >Array.from : { <T>(arrayLike: ArrayLike<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; <T>(iterable: Iterable<T> | ArrayLike<T>): T[]; <T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; }
 >Array : ArrayConstructor
 >from : { <T>(arrayLike: ArrayLike<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; <T>(iterable: Iterable<T> | ArrayLike<T>): T[]; <T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; }
 >a : Set<Nominal<"A", string>>
->concat : { (...items: ConcatArray<Nominal<"A", string>>[]): Nominal<"A", string>[]; (...items: (Nominal<"A", string> | ConcatArray<Nominal<"A", string>>)[]): Nominal<"A", string>[]; }
+>concat : { <U>(...items: ConcatArray<U>[]): (Nominal<"A", string> | U)[]; <U>(...items: (U | ConcatArray<U>)[]): (Nominal<"A", string> | U)[]; }
 >Array.from(b) : Nominal<"A", string>[]
 >Array.from : { <T>(arrayLike: ArrayLike<T>): T[]; <T, U>(arrayLike: ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; <T>(iterable: Iterable<T> | ArrayLike<T>): T[]; <T, U>(iterable: Iterable<T> | ArrayLike<T>, mapfn: (v: T, k: number) => U, thisArg?: any): U[]; }
 >Array : ArrayConstructor