Merge pull request #640 from Microsoft/contextualSignatureInstantiation

Fix contextual signature instantiation during type inference

Author: ahejlsberg

src/compiler/checker.ts

@@ -4088,19 +4088,6 @@ module ts {
             return getSignatureInstantiation(signature, getInferredTypes(context));
         }
 
-        // Inferentially type an expression by a contextual parameter type (section 4.12.2 in TypeScript spec)
-        function inferentiallyTypeExpession(expr: Expression, contextualType: Type, contextualMapper: TypeMapper): Type {
-            var type = checkExpressionWithContextualType(expr, contextualType, contextualMapper);
-            var signature = getSingleCallSignature(type);
-            if (signature && signature.typeParameters) {
-                var contextualSignature = getSingleCallSignature(contextualType);
-                if (contextualSignature && !contextualSignature.typeParameters) {
-                    type = getOrCreateTypeFromSignature(instantiateSignatureInContextOf(signature, contextualSignature, contextualMapper));
-                }
-            }
-            return type;
-        }
-
         function inferTypeArguments(signature: Signature, args: Expression[], excludeArgument?: boolean[]): Type[] {
             var typeParameters = signature.typeParameters;
             var context = createInferenceContext(typeParameters);
@@ -4109,15 +4096,15 @@ module ts {
             for (var i = 0; i < args.length; i++) {
                 if (!excludeArgument || excludeArgument[i] === undefined) {
                     var parameterType = getTypeAtPosition(signature, i);
-                    inferTypes(context, inferentiallyTypeExpession(args[i], parameterType, mapper), parameterType);
+                    inferTypes(context, checkExpressionWithContextualType(args[i], parameterType, mapper), parameterType);
                 }
             }
             // Next, infer from those context sensitive arguments that are no longer excluded
             if (excludeArgument) {
                 for (var i = 0; i < args.length; i++) {
                     if (excludeArgument[i] === false) {
                         var parameterType = getTypeAtPosition(signature, i);
-                        inferTypes(context, inferentiallyTypeExpession(args[i], parameterType, mapper), parameterType);
+                        inferTypes(context, checkExpressionWithContextualType(args[i], parameterType, mapper), parameterType);
                     }
                 }
             }
@@ -4852,6 +4839,23 @@ module ts {
         // have the wildcard function type; this form of type check is used during overload resolution to exclude
         // contextually typed function and arrow expressions in the initial phase.
         function checkExpression(node: Expression, contextualMapper?: TypeMapper): Type {
+            var type = checkExpressionNode(node, contextualMapper);
+            if (contextualMapper && contextualMapper !== identityMapper) {
+                var signature = getSingleCallSignature(type);
+                if (signature && signature.typeParameters) {
+                    var contextualType = getContextualType(node);
+                    if (contextualType) {
+                        var contextualSignature = getSingleCallSignature(contextualType);
+                        if (contextualSignature && !contextualSignature.typeParameters) {
+                            type = getOrCreateTypeFromSignature(instantiateSignatureInContextOf(signature, contextualSignature, contextualMapper));
+                        }
+                    }
+                }
+            }
+            return type;
+        }
+
+        function checkExpressionNode(node: Expression, contextualMapper: TypeMapper): Type {
             switch (node.kind) {
                 case SyntaxKind.Identifier:
                     return checkIdentifier(<Identifier>node);

tests/baselines/reference/genericCallWithFunctionTypedArguments5.errors.txt

@@ -10,9 +10,9 @@
     // more args not allowed
     var r2 = foo({ cb: <T>(x: T, y: T) => '' }); // error
                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-!!! Argument of type '{ cb: <T>(x: T, y: T) => string; }' is not assignable to parameter of type '{ cb: (t: any) => string; }'.
+!!! Argument of type '{ cb: <T>(x: T, y: T) => string; }' is not assignable to parameter of type '{ cb: (t: {}) => string; }'.
 !!!   Types of property 'cb' are incompatible:
-!!!     Type '<T>(x: T, y: T) => string' is not assignable to type '(t: any) => string'.
+!!!     Type '<T>(x: T, y: T) => string' is not assignable to type '(t: {}) => string'.
     var r3 = foo({ cb: (x: string, y: number) => '' }); // error
                  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 !!! Argument of type '{ cb: (x: string, y: number) => string; }' is not assignable to parameter of type '{ cb: (t: string) => string; }'.

tests/baselines/reference/inferentialTypingWithFunctionTypeNested.types

@@ -20,10 +20,10 @@ declare function identity<V>(y: V): V;
 >V : V
 
 var s = map("", () => { return { x: identity }; });
->s : any
->map("", () => { return { x: identity }; }) : any
+>s : string
+>map("", () => { return { x: identity }; }) : string
 >map : <T, U>(x: T, f: () => { x: (s: T) => U; }) => U
->() => { return { x: identity }; } : () => { x: <V>(y: V) => V; }
+>() => { return { x: identity }; } : () => { x: (y: string) => string; }
 >{ x: identity } : { x: <V>(y: V) => V; }
 >x : <V>(y: V) => V
 >identity : <V>(y: V) => V