Combine multiple overloads into a single contextual signature

src/compiler/types.ts

@@ -5548,7 +5548,9 @@ namespace ts {
         /* @internal */
         mapper?: TypeMapper;                // Instantiation mapper
         /* @internal */
-        unionSignatures?: Signature[];      // Underlying signatures of a union signature
+        compositeSignatures?: Signature[];  // Underlying signatures of a union/intersection signature
+        /* @internal */
+        compositeKind?: TypeFlags;          // TypeFlags.Union if the underlying signatures are from union members, otherwise TypeFlags.Intersection
         /* @internal */
         erasedSignatureCache?: Signature;   // Erased version of signature (deferred)
         /* @internal */

tests/baselines/reference/callsOnComplexSignatures.types

@@ -100,13 +100,13 @@ function test3(items: string[] | number[]) {
 >items.forEach : ((callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void) | ((callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void)
 >items : string[] | number[]
 >forEach : ((callbackfn: (value: string, index: number, array: string[]) => void, thisArg?: any) => void) | ((callbackfn: (value: number, index: number, array: number[]) => void, thisArg?: any) => void)
->item => console.log(item) : (item: any) => void
->item : any
+>item => console.log(item) : (item: string | number) => void
+>item : string | number
 >console.log(item) : void
 >console.log : (...data: any[]) => void
 >console : Console
 >log : (...data: any[]) => void
->item : any
+>item : string | number
 }
 
 function test4(

tests/baselines/reference/circularlySimplifyingConditionalTypesNoCrash.types

@@ -56,7 +56,7 @@ declare var connect: Connect;
 
 const myStoreConnect: Connect = function(
 >myStoreConnect : Connect
->function(    mapStateToProps?: any,    mapDispatchToProps?: any,    mergeProps?: any,    options: unknown = {},) {    return connect(        mapStateToProps,        mapDispatchToProps,        mergeProps,        options,    );} : (mapStateToProps?: any, mapDispatchToProps?: any, mergeProps?: any, options?: unknown) => InferableComponentEnhancerWithProps<unknown, unknown>
+>function(    mapStateToProps?: any,    mapDispatchToProps?: any,    mergeProps?: any,    options: unknown = {},) {    return connect(        mapStateToProps,        mapDispatchToProps,        mergeProps,        options,    );} : <TStateProps, TOwnProps>(mapStateToProps?: any, mapDispatchToProps?: any, mergeProps?: any, options?: unknown) => InferableComponentEnhancerWithProps<TStateProps, Omit<P, Extract<keyof TStateProps, keyof P>> & TOwnProps>
 
     mapStateToProps?: any,
 >mapStateToProps : any
@@ -73,7 +73,7 @@ const myStoreConnect: Connect = function(
 
 ) {
     return connect(
->connect(        mapStateToProps,        mapDispatchToProps,        mergeProps,        options,    ) : InferableComponentEnhancerWithProps<unknown, unknown>
+>connect(        mapStateToProps,        mapDispatchToProps,        mergeProps,        options,    ) : InferableComponentEnhancerWithProps<TStateProps, Omit<P, Extract<keyof TStateProps, keyof P>> & TOwnProps>
 >connect : Connect
 
         mapStateToProps,

tests/baselines/reference/contextualOverloadListFromArrayUnion.js

@@ -0,0 +1,111 @@
+//// [tests/cases/compiler/contextualOverloadListFromArrayUnion.ts] ////
+
+//// [one.ts]
+declare const y: never[] | string[];
+export const yThen = y.map(item => item.length);
+//// [two.ts]
+declare const y: number[][] | string[];
+export const yThen = y.map(item => item.length);
+//// [three.ts]
+// #42504
+interface ResizeObserverCallback {
+    (entries: ResizeObserverEntry[], observer: ResizeObserver): void;
+}
+interface ResizeObserverCallback { // duplicate for effect
+    (entries: ResizeObserverEntry[], observer: ResizeObserver): void;
+}
+
+const resizeObserver = new ResizeObserver(([entry]) => {
+    entry
+});
+// comment in #35501
+interface Callback<T> {
+    (error: null, result: T): unknown
+    (error: Error, result: null): unknown
+}
+
+interface Task<T> {
+    (callback: Callback<T>): unknown
+}
+
+export function series<T>(tasks: Task<T>[], callback: Callback<T[]>): void {
+    let index = 0
+    let results: T[] = []
+
+    function next() {
+        let task = tasks[index]
+        if (!task) {
+            callback(null, results)
+        } else {
+            task((error, result) => {
+                if (error) {
+                    callback(error, null)
+                } else {
+                    // must use postfix-!, since `error` and `result` don't have a
+                    // causal relationship when the overloads are combined
+                    results.push(result!)
+                    next()
+                }
+            })
+        }
+    }
+    next()
+}
+
+series([
+    cb => setTimeout(() => cb(null, 1), 300),
+    cb => setTimeout(() => cb(null, 2), 200),
+    cb => setTimeout(() => cb(null, 3), 100),
+], (error, results) => {
+    if (error) {
+        console.error(error)
+    } else {
+        console.log(results)
+    }
+})
+
+
+//// [one.js]
+export const yThen = y.map(item => item.length);
+//// [two.js]
+export const yThen = y.map(item => item.length);
+//// [three.js]
+const resizeObserver = new ResizeObserver(([entry]) => {
+    entry;
+});
+export function series(tasks, callback) {
+    let index = 0;
+    let results = [];
+    function next() {
+        let task = tasks[index];
+        if (!task) {
+            callback(null, results);
+        }
+        else {
+            task((error, result) => {
+                if (error) {
+                    callback(error, null);
+                }
+                else {
+                    // must use postfix-!, since `error` and `result` don't have a
+                    // causal relationship when the overloads are combined
+                    results.push(result);
+                    next();
+                }
+            });
+        }
+    }
+    next();
+}
+series([
+    cb => setTimeout(() => cb(null, 1), 300),
+    cb => setTimeout(() => cb(null, 2), 200),
+    cb => setTimeout(() => cb(null, 3), 100),
+], (error, results) => {
+    if (error) {
+        console.error(error);
+    }
+    else {
+        console.log(results);
+    }
+});