Allow calls on unions of dissimilar signatures (#29011)

* Add core of new union signature logic and test - needs intersection signature logic to fully work

* Add inversion of variance for class props lookup from union sig returns

* Fix lints

* Combine parameter names for nicer quick info

* PR feedback 1

* Fix miscopy

* PR feedback round 2

* Remove argument name combining because loc :(

* Nit cleanup round 3

* Reinline getTupleTypeForArgumentAtPos

* Remove a tad more

* No step on sneky off-by-one error

Author: weswigham

src/compiler/checker.ts

@@ -6799,7 +6799,12 @@ namespace ts {
         // type is the union of the constituent return types.
         function getUnionSignatures(signatureLists: ReadonlyArray<ReadonlyArray<Signature>>): Signature[] {
             let result: Signature[] | undefined;
+            let indexWithLengthOverOne: number | undefined;
             for (let i = 0; i < signatureLists.length; i++) {
+                if (signatureLists[i].length === 0) return emptyArray;
+                if (signatureLists[i].length > 1) {
+                    indexWithLengthOverOne = indexWithLengthOverOne === undefined ? i : -1; // -1 is a signal there are multiple overload sets
+                }
                 for (const signature of signatureLists[i]) {
                     // Only process signatures with parameter lists that aren't already in the result list
                     if (!result || !findMatchingSignature(result, signature, /*partialMatch*/ false, /*ignoreThisTypes*/ true, /*ignoreReturnTypes*/ true)) {
@@ -6823,9 +6828,91 @@ namespace ts {
                     }
                 }
             }
+            if (!length(result) && indexWithLengthOverOne !== -1) {
+                // No sufficiently similar signature existed to subsume all the other signatures in the union - time to see if we can make a single
+                // signature that handles all over them. We only do this when there are overloads in only one constituent.
+                // (Overloads are conditional in nature and having overloads in multiple constituents would necessitate making a power set of
+                // signatures from the type, whose ordering would be non-obvious)
+                const masterList = signatureLists[indexWithLengthOverOne !== undefined ? indexWithLengthOverOne : 0];
+                let results: Signature[] | undefined = masterList.slice();
+                for (const signatures of signatureLists) {
+                    if (signatures !== masterList) {
+                        const signature = signatures[0];
+                        Debug.assert(!!signature, "getUnionSignatures bails early on empty signature lists and should not have empty lists on second pass");
+                        results = signature.typeParameters && some(results, s => !!s.typeParameters) ? undefined : map(results, sig => combineSignaturesOfUnionMembers(sig, signature));
+                        if (!results) {
+                            break;
+                        }
+                    }
+                }
+                result = results;
+            }
             return result || emptyArray;
         }
 
+        function combineUnionThisParam(left: Symbol | undefined, right: Symbol | undefined): Symbol | undefined {
+            if (!left || !right) {
+                return left || right;
+            }
+            // A signature `this` type might be a read or a write position... It's very possible that it should be invariant
+            // and we should refuse to merge signatures if there are `this` types and they do not match. However, so as to be
+            // permissive when calling, for now, we'll union the `this` types just like the overlapping-union-signature check does
+            const thisType = getUnionType([getTypeOfSymbol(left), getTypeOfSymbol(right)], UnionReduction.Subtype);
+            return createSymbolWithType(left, thisType);
+        }
+
+        function combineUnionParameters(left: Signature, right: Signature) {
+            const longest = getParameterCount(left) >= getParameterCount(right) ? left : right;
+            const shorter = longest === left ? right : left;
+            const longestCount = getParameterCount(longest);
+            const eitherHasEffectiveRest = (hasEffectiveRestParameter(left) || hasEffectiveRestParameter(right));
+            const needsExtraRestElement = eitherHasEffectiveRest && !hasEffectiveRestParameter(longest);
+            const params = new Array<Symbol>(longestCount + (needsExtraRestElement ? 1 : 0));
+            for (let i = 0; i < longestCount; i++) {
+                const longestParamType = tryGetTypeAtPosition(longest, i)!;
+                const shorterParamType = tryGetTypeAtPosition(shorter, i) || unknownType;
+                const unionParamType = getIntersectionType([longestParamType, shorterParamType]);
+                const isRestParam = eitherHasEffectiveRest && !needsExtraRestElement && i === (longestCount - 1);
+                const isOptional = i >= getMinArgumentCount(longest) && i >= getMinArgumentCount(shorter);
+                const leftName = getParameterNameAtPosition(left, i);
+                const rightName = getParameterNameAtPosition(right, i);
+                const paramSymbol = createSymbol(
+                    SymbolFlags.FunctionScopedVariable | (isOptional && !isRestParam ? SymbolFlags.Optional : 0),
+                    leftName === rightName ? leftName : `arg${i}` as __String
+                );
+                paramSymbol.type = isRestParam ? createArrayType(unionParamType) : unionParamType;
+                params[i] = paramSymbol;
+            }
+            if (needsExtraRestElement) {
+                const restParamSymbol = createSymbol(SymbolFlags.FunctionScopedVariable, "args" as __String);
+                restParamSymbol.type = createArrayType(getTypeAtPosition(shorter, longestCount));
+                params[longestCount] = restParamSymbol;
+            }
+            return params;
+        }
+
+        function combineSignaturesOfUnionMembers(left: Signature, right: Signature): Signature {
+            const declaration = left.declaration;
+            const params = combineUnionParameters(left, right);
+            const thisParam = combineUnionThisParam(left.thisParameter, right.thisParameter);
+            const minArgCount = Math.max(left.minArgumentCount, right.minArgumentCount);
+            const hasRestParam = left.hasRestParameter || right.hasRestParameter;
+            const hasLiteralTypes = left.hasLiteralTypes || right.hasLiteralTypes;
+            const result = createSignature(
+                declaration,
+                left.typeParameters || right.typeParameters,
+                thisParam,
+                params,
+                /*resolvedReturnType*/ undefined,
+                /*resolvedTypePredicate*/ undefined,
+                minArgCount,
+                hasRestParam,
+                hasLiteralTypes
+            );
+            result.unionSignatures = concatenate(left.unionSignatures || [left], [right]);
+            return result;
+        }
+
         function getUnionIndexInfo(types: ReadonlyArray<Type>, kind: IndexKind): IndexInfo | undefined {
             const indexTypes: Type[] = [];
             let isAnyReadonly = false;
@@ -17566,6 +17653,26 @@ namespace ts {
         }
 
         function getJsxPropsTypeForSignatureFromMember(sig: Signature, forcedLookupLocation: __String) {
+            if (sig.unionSignatures) {
+                // JSX Elements using the legacy `props`-field based lookup (eg, react class components) need to treat the `props` member as an input
+                // instead of an output position when resolving the signature. We need to go back to the input signatures of the composite signature,
+                // get the type of `props` on each return type individually, and then _intersect them_, rather than union them (as would normally occur
+                // for a union signature). It's an unfortunate quirk of looking in the output of the signature for the type we want to use for the input.
+                // The default behavior of `getTypeOfFirstParameterOfSignatureWithFallback` when no `props` member name is defined is much more sane.
+                const results: Type[] = [];
+                for (const signature of sig.unionSignatures) {
+                    const instance = getReturnTypeOfSignature(signature);
+                    if (isTypeAny(instance)) {
+                        return instance;
+                    }
+                    const propType = getTypeOfPropertyOfType(instance, forcedLookupLocation);
+                    if (!propType) {
+                        return;
+                    }
+                    results.push(propType);
+                }
+                return getIntersectionType(results);
+            }
             const instanceType = getReturnTypeOfSignature(sig);
             return isTypeAny(instanceType) ? instanceType : getTypeOfPropertyOfType(instanceType, forcedLookupLocation);
         }

tests/baselines/reference/callsOnComplexSignatures.errors.txt

@@ -0,0 +1,110 @@
+tests/cases/compiler/callsOnComplexSignatures.tsx(38,19): error TS7006: Parameter 'item' implicitly has an 'any' type.
+
+
+==== tests/cases/compiler/callsOnComplexSignatures.tsx (1 errors) ====
+    /// <reference path="/.lib/react16.d.ts" />
+    import React from "react";
+    
+    // Simple calls from real usecases
+    function test1() {
+        type stringType1 = "foo" | "bar";
+        type stringType2 = "baz" | "bar";
+    
+        interface Temp1 {
+            getValue(name: stringType1): number;
+        }
+    
+        interface Temp2 {
+            getValue(name: stringType2): string;
+        }
+    
+        function test(t: Temp1 | Temp2) {
+            const z = t.getValue("bar"); // Should be fine
+        }
+    }
+    
+    function test2() {
+        interface Messages {
+            readonly foo: (options: { [key: string]: any, b: number }) => string;
+            readonly bar: (options: { [key: string]: any, a: string }) => string;
+        }
+    
+        const messages: Messages = {
+            foo: (options) => "Foo",
+            bar: (options) => "Bar",
+        };
+    
+        const test1 = (type: "foo" | "bar") =>
+            messages[type]({ a: "A", b: 0 });
+    }
+    
+    function test3(items: string[] | number[]) {
+        items.forEach(item => console.log(item));
+                      ~~~~
+!!! error TS7006: Parameter 'item' implicitly has an 'any' type.
+    }
+    
+    function test4(
+        arg1: ((...objs: {x: number}[]) => number) | ((...objs: {y: number}[]) => number),
+        arg2: ((a: {x: number}, b: object) => number) | ((a: object, b: {x: number}) => number),
+        arg3: ((a: {x: number}, ...objs: {y: number}[]) => number) | ((...objs: {x: number}[]) => number),
+        arg4: ((a?: {x: number}, b?: {x: number}) => number) | ((a?: {y: number}) => number),
+        arg5: ((a?: {x: number}, ...b: {x: number}[]) => number) | ((a?: {y: number}) => number),
+        arg6: ((a?: {x: number}, b?: {x: number}) => number) | ((...a: {y: number}[]) => number),
+    ) {
+        arg1();
+        arg1({x: 0, y: 0});
+        arg1({x: 0, y: 0}, {x: 1, y: 1});
+    
+        arg2({x: 0}, {x: 0});
+    
+        arg3({x: 0});
+        arg3({x: 0}, {x: 0, y: 0});
+        arg3({x: 0}, {x: 0, y: 0}, {x: 0, y: 0});
+    
+        arg4();
+        arg4({x: 0, y: 0});
+        arg4({x: 0, y: 0}, {x: 0});
+    
+        arg5();
+        arg5({x: 0, y: 0});
+        arg5({x: 0, y: 0}, {x: 0});
+    
+        arg6();
+        arg6({x: 0, y: 0});
+        arg6({x: 0, y: 0}, {x: 0, y: 0});
+        arg6({x: 0, y: 0}, {x: 0, y: 0}, {y: 0});
+    }
+    
+    // JSX Tag names
+    function test5() {
+        // Pair of non-like intrinsics
+        function render(url?: string): React.ReactNode {
+            const Tag = url ? 'a' : 'button';
+            return <Tag>test</Tag>;
+        }
+    
+        // Union of all intrinsics and components of `any`
+        function App(props: { component:React.ReactType }) {
+            const Comp: React.ReactType = props.component;
+            return (<Comp />);
+        }
+    
+        // custom components with non-subset props
+        function render2() {
+            interface P1 {
+                p?: boolean;
+                c?: string;
+            }
+            interface P2 {
+                p?: boolean;
+                c?: any;
+                d?: any;
+            }
+    
+            var C: React.ComponentType<P1> | React.ComponentType<P2> = null as any;
+    
+            const a = <C p={true} />;
+        }
+    }
+