Always combine nonlike call signatures, regarless of source type

Author: weswigham

src/compiler/checker.ts

@@ -6597,8 +6597,8 @@ namespace ts {
             return signature.resolvedReturnType;
         }
 
-        function isResolvingReturnTypeOfSignature(signature: Signature) {
-            return !signature.resolvedReturnType && findResolutionCycleStartIndex(signature, TypeSystemPropertyName.ResolvedReturnType) >= 0;
+        function isResolvingReturnTypeOfSignature(signature: Signature): boolean {
+            return !signature.resolvedReturnType && findResolutionCycleStartIndex(signature, TypeSystemPropertyName.ResolvedReturnType) >= 0 || (signature.unionSignatures && some(signature.unionSignatures, s => isResolvingReturnTypeOfSignature(s)));
         }
 
         function getRestTypeOfSignature(signature: Signature): Type {
@@ -13329,14 +13329,8 @@ namespace ts {
 
         // If the given type is an object or union type with a single signature, and if that signature has at
         // least as many parameters as the given function, return the signature. Otherwise return undefined.
-        function getContextualCallSignature(type: Type, node: FunctionExpression | ArrowFunction | MethodDeclaration): Signature {
-            const signatures = getSignaturesOfStructuredType(type, SignatureKind.Call);
-            if (signatures.length === 1) {
-                const signature = signatures[0];
-                if (!isAritySmaller(signature, node)) {
-                    return signature;
-                }
-            }
+        function getContextualCallSignatures(type: Type, node: FunctionExpression | ArrowFunction | MethodDeclaration): Signature[] {
+            return filter(getSignaturesOfStructuredType(type, SignatureKind.Call), s => !isAritySmaller(s, node));
         }
 
         /** If the contextual signature has fewer parameters than the function expression, do not use it */
@@ -13372,7 +13366,7 @@ namespace ts {
                 getApparentTypeOfContextualType(node);
         }
 
-        function combineSignatures(signatureList: Signature[]): Signature {
+        function combineSignatures(signatureList: Signature[], declaration?: SignatureDeclaration): Signature {
             // Produce a synthetic signature whose arguments are a union of the parameters of the inferred signatures and whose return type is an intersection
             let parameters: Symbol[];
             let minimumParameterCount = Number.POSITIVE_INFINITY;
@@ -13428,8 +13422,9 @@ namespace ts {
                         parameterTypes.push(type);
                     }
                 }
-                // We do this so the name is reasonable for users
-                const paramName = escapeLeadingUnderscores(map(parameterNames, unescapeLeadingUnderscores).join("or"));
+                // We do this so the name is reasonable for users; however it is very rare for this symbol name to appear anywhere user-facing, as the result signature is used only for contextual typing
+                const canUseUserSuppliedName = declaration && declaration.parameters && declaration.parameters[i] && isIdentifier(declaration.parameters[i].name);
+                const paramName = canUseUserSuppliedName ? (declaration.parameters[i].name as Identifier).escapedText : escapeLeadingUnderscores(map(parameterNames, unescapeLeadingUnderscores).join("or"));
                 const paramSymbol = createSymbol(SymbolFlags.FunctionScopedVariable, paramName);
                 paramSymbol.type = getUnionType(parameterTypes);
                 (parameters || (parameters = [])).push(paramSymbol);
@@ -13451,7 +13446,7 @@ namespace ts {
 
             // TODO (weswigham): Merge type predicates?
             return createSignature(
-                /*declaration*/ undefined,
+                declaration,
                 map(flatMap(signatureList, s => s.typeParameters), cloneTypeParameter),
                 thisParameterSymbol,
                 parameters,
@@ -13474,43 +13469,45 @@ namespace ts {
             if (!type) {
                 return undefined;
             }
+            let signatureList: Signature[];
             if (!(type.flags & TypeFlags.Union)) {
-                return getContextualCallSignature(type, node);
+                signatureList = getContextualCallSignatures(type, node);
             }
-            let signatureList: Signature[];
-            const types = (<UnionType>type).types;
-            let mismatchedSignatures = false;
-            for (const current of types) {
-                const signature = getContextualCallSignature(current, node);
-                if (signature) {
-                    if (!signatureList) {
-                        // This signature will contribute to contextual union signature
-                        signatureList = [signature];
-                    }
-                    else if (!compareSignaturesIdentical(signatureList[0], signature, /*partialMatch*/ false, /*ignoreThisTypes*/ true, /*ignoreReturnTypes*/ true, compareTypesIdentical)) {
-                        // Signatures aren't identical, set flag to union parameter types, intersect return types
-                        signatureList.push(signature);
-                        mismatchedSignatures = true;
-                    }
-                    else {
-                        // Use this signature for contextual union signature
-                        signatureList.push(signature);
+            else {
+                const types = (<UnionType>type).types;
+                for (const current of types) {
+                    const signatures = getContextualCallSignatures(current, node);
+                    if (signatures && signatures.length) {
+                        if (!signatureList) {
+                            signatureList = signatures;
+                        }
+                        else {
+                            signatureList = signatureList.concat(signatures);
+                        }
                     }
                 }
             }
 
-            if (mismatchedSignatures) {
-                return combineSignatures(signatureList);
+            if (!(signatureList && signatureList.length)) {
+                return undefined;
             }
 
-            // Result is union of signatures collected (return type is union of return types of this signature set)
-            let result: Signature;
-            if (signatureList) {
-                result = cloneSignature(signatureList[0]);
-                // Clear resolved return type we possibly got from cloneSignature
-                result.resolvedReturnType = undefined;
-                result.unionSignatures = signatureList;
+            if (signatureList.length === 1) {
+                return signatureList[0];
             }
+
+            for (const signature of signatureList) {
+                if (!compareSignaturesIdentical(signatureList[0], signature, /*partialMatch*/ false, /*ignoreThisTypes*/ true, /*ignoreReturnTypes*/ true, compareTypesIdentical)) {
+                    // Signatures not simply identical, combine them
+                    return combineSignatures(signatureList, node);
+                }
+            }
+
+            // Result is union of signatures collected (return type is union of return types of this signature set)
+            const result = cloneSignature(signatureList[0]);
+            // Clear resolved return type we possibly got from cloneSignature
+            result.resolvedReturnType = undefined;
+            result.unionSignatures = signatureList;
             return result;
         }
 
@@ -16989,7 +16986,7 @@ namespace ts {
             if (isUnitType(type) &&
                 !(contextualSignature &&
                     isLiteralContextualType(
-                        contextualSignature === getSignatureFromDeclaration(func) ? type : getReturnTypeOfSignature(contextualSignature)))) {
+                        (contextualSignature === getSignatureFromDeclaration(func) || contextualSignature.unionSignatures && some(contextualSignature.unionSignatures, s => s === getSignatureFromDeclaration(func))) ? type : getReturnTypeOfSignature(contextualSignature)))) {
                 type = getWidenedLiteralType(type);
             }
 

tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.symbols

@@ -84,7 +84,7 @@ var x4: IWithCallSignatures | IWithCallSignatures4 = a => /*here a should be any
 >IWithCallSignatures : Symbol(IWithCallSignatures, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 9, 1))
 >IWithCallSignatures4 : Symbol(IWithCallSignatures4, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 18, 1))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 35, 52))
->a.toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>a.toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >a : Symbol(a, Decl(contextualTypeWithUnionTypeCallSignatures.ts, 35, 52))
->toString : Symbol(Number.toString, Decl(lib.d.ts, --, --))
+>toString : Symbol(toString, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 

tests/baselines/reference/contextualTypeWithUnionTypeCallSignatures.types

@@ -90,10 +90,10 @@ var x4: IWithCallSignatures | IWithCallSignatures4 = a => /*here a should be any
 >x4 : IWithCallSignatures | IWithCallSignatures4
 >IWithCallSignatures : IWithCallSignatures
 >IWithCallSignatures4 : IWithCallSignatures4
->a => /*here a should be any*/ a.toString() : (a: number) => string
->a : number
+>a => /*here a should be any*/ a.toString() : (a: string | number) => string
+>a : string | number
 >a.toString() : string
->a.toString : (radix?: number) => string
->a : number
->toString : (radix?: number) => string
+>a.toString : ((radix?: number) => string) | (() => string)
+>a : string | number
+>toString : ((radix?: number) => string) | (() => string)
 

tests/baselines/reference/contextualTyping.errors.txt

@@ -1,11 +1,14 @@
+tests/cases/compiler/contextualTyping.ts(36,5): error TS2322: Type '(n: string | number) => string | number' is not assignable to type '{ (n: number): number; (s1: string): number; }'.
+  Type 'string | number' is not assignable to type 'number'.
+    Type 'string' is not assignable to type 'number'.
 tests/cases/compiler/contextualTyping.ts(189,18): error TS2384: Overload signatures must all be ambient or non-ambient.
 tests/cases/compiler/contextualTyping.ts(197,15): error TS2300: Duplicate identifier 'Point'.
 tests/cases/compiler/contextualTyping.ts(207,10): error TS2300: Duplicate identifier 'Point'.
 tests/cases/compiler/contextualTyping.ts(230,5): error TS2322: Type '{}' is not assignable to type 'B'.
   Property 'x' is missing in type '{}'.
 
 
-==== tests/cases/compiler/contextualTyping.ts (4 errors) ====
+==== tests/cases/compiler/contextualTyping.ts (5 errors) ====
     // DEFAULT INTERFACES
     interface IFoo {
         n: number;
@@ -42,6 +45,10 @@ tests/cases/compiler/contextualTyping.ts(230,5): error TS2322: Type '{}' is not
     var c3t5: (n: number) => IFoo = function(n) { return <IFoo>({}) };
     var c3t6: (n: number, s: string) => IFoo = function(n, s) { return <IFoo>({}) };
     var c3t7: {
+        ~~~~
+!!! error TS2322: Type '(n: string | number) => string | number' is not assignable to type '{ (n: number): number; (s1: string): number; }'.
+!!! error TS2322:   Type 'string | number' is not assignable to type 'number'.
+!!! error TS2322:     Type 'string' is not assignable to type 'number'.
         (n: number): number;    
         (s1: string): number;
     } = function(n) { return n; };

tests/baselines/reference/contextualTypingOfLambdaWithMultipleSignatures.types

@@ -16,10 +16,10 @@ var foo: Foo;
 >Foo : Foo
 
 foo.getFoo = bar => { };
->foo.getFoo = bar => { } : (bar: any) => void
+>foo.getFoo = bar => { } : (bar: string | number) => void
 >foo.getFoo : { (n: number): void; (s: string): void; }
 >foo : Foo
 >getFoo : { (n: number): void; (s: string): void; }
->bar => { } : (bar: any) => void
->bar : any
+>bar => { } : (bar: string | number) => void
+>bar : string | number
 

tests/baselines/reference/contextualTypingOfLambdaWithMultipleSignatures2.errors.txt

@@ -0,0 +1,14 @@
+tests/cases/compiler/contextualTypingOfLambdaWithMultipleSignatures2.ts(6,23): error TS2339: Property 'asdf' does not exist on type 'string | number'.
+  Property 'asdf' does not exist on type 'string'.
+
+
+==== tests/cases/compiler/contextualTypingOfLambdaWithMultipleSignatures2.ts (1 errors) ====
+    var f: {
+        (x: string): string;
+        (x: number): string
+    };
+    
+    f = (a) => { return a.asdf }
+                          ~~~~
+!!! error TS2339: Property 'asdf' does not exist on type 'string | number'.
+!!! error TS2339:   Property 'asdf' does not exist on type 'string'.

tests/baselines/reference/contextualTypingWithGenericAndNonGenericSignature.errors.txt

@@ -0,0 +1,33 @@
+tests/cases/compiler/contextualTypingWithGenericAndNonGenericSignature.ts(8,1): error TS2322: Type '<T, U>(x: string | T, y: number | U) => string | T' is not assignable to type '{ (x: string, y: number): string; <T, U>(x: T, y: U): T; }'.
+  Type 'string | T' is not assignable to type 'string'.
+    Type 'T' is not assignable to type 'string'.
+tests/cases/compiler/contextualTypingWithGenericAndNonGenericSignature.ts(15,1): error TS2322: Type '<T, U>(x: string | T, y: number | U) => string | T' is not assignable to type '{ <T, U>(x: T, y: U): T; (x: string, y: number): string; }'.
+  Type 'string | T' is not assignable to type 'string'.
+    Type 'T' is not assignable to type 'string'.
+
+
+==== tests/cases/compiler/contextualTypingWithGenericAndNonGenericSignature.ts (2 errors) ====
+    //•	If e is a FunctionExpression or ArrowFunctionExpression with no type parameters and no parameter or return type annotations, and T is a function type with EXACTLY ONE non - generic call signature, then any inferences made for type parameters referenced by the parameters of T’s call signature are fixed(section 4.12.2) and e is processed with the contextual type T, as described in section 4.9.3.
+    
+    var f2: {
+        (x: string, y: number): string;
+        <T, U>(x: T, y: U): T
+    };
+    
+    f2 = (x, y) => { return x }
+    ~~
+!!! error TS2322: Type '<T, U>(x: string | T, y: number | U) => string | T' is not assignable to type '{ (x: string, y: number): string; <T, U>(x: T, y: U): T; }'.
+!!! error TS2322:   Type 'string | T' is not assignable to type 'string'.
+!!! error TS2322:     Type 'T' is not assignable to type 'string'.
+    
+    var f3: {
+        <T, U>(x: T, y: U): T
+        (x: string, y: number): string;
+    };
+    
+    f3 = (x, y) => { return x }
+    ~~
+!!! error TS2322: Type '<T, U>(x: string | T, y: number | U) => string | T' is not assignable to type '{ <T, U>(x: T, y: U): T; (x: string, y: number): string; }'.
+!!! error TS2322:   Type 'string | T' is not assignable to type 'string'.
+!!! error TS2322:     Type 'T' is not assignable to type 'string'.
+    

tests/baselines/reference/functionLiteralForOverloads.errors.txt

@@ -0,0 +1,38 @@
+tests/cases/conformance/types/specifyingTypes/typeLiterals/functionLiteralForOverloads.ts(3,5): error TS2322: Type '(x: string | number) => string | number' is not assignable to type '{ (x: string): string; (x: number): number; }'.
+  Type 'string | number' is not assignable to type 'string'.
+    Type 'number' is not assignable to type 'string'.
+tests/cases/conformance/types/specifyingTypes/typeLiterals/functionLiteralForOverloads.ts(8,5): error TS2322: Type '<T, T>(x: string | number) => string | number' is not assignable to type '{ <T>(x: string): string; <T>(x: number): number; }'.
+  Type 'string | number' is not assignable to type 'string'.
+    Type 'number' is not assignable to type 'string'.
+
+
+==== tests/cases/conformance/types/specifyingTypes/typeLiterals/functionLiteralForOverloads.ts (2 errors) ====
+    // basic uses of function literals with overloads
+    
+    var f: {
+        ~
+!!! error TS2322: Type '(x: string | number) => string | number' is not assignable to type '{ (x: string): string; (x: number): number; }'.
+!!! error TS2322:   Type 'string | number' is not assignable to type 'string'.
+!!! error TS2322:     Type 'number' is not assignable to type 'string'.
+        (x: string): string;
+        (x: number): number;
+    } = (x) => x;
+    
+    var f2: {
+        ~~
+!!! error TS2322: Type '<T, T>(x: string | number) => string | number' is not assignable to type '{ <T>(x: string): string; <T>(x: number): number; }'.
+!!! error TS2322:   Type 'string | number' is not assignable to type 'string'.
+!!! error TS2322:     Type 'number' is not assignable to type 'string'.
+        <T>(x: string): string;
+        <T>(x: number): number;
+    } = (x) => x;
+    
+    var f3: {
+        <T>(x: T): string;
+        <T>(x: T): number;
+    } = (x) => x;
+    
+    var f4: {
+        <T>(x: string): T;
+        <T>(x: number): T;
+    } = (x) => x;