Function parameter only gets inferentially typed if a type parameter coincides with it

[JsonFreeman]

In inferential typing, we only fix a type parameter and contextually type a function parameter if the inference walker hits the type parameter and the function parameter at the same time (foo2 below). Ideally, we would also want this to work if the walker hits the type parameter before hitting the function parameter in the argument (foo1). At that point, we may fix the type parameter, and then keep drilling into it, then use the relevant part when we hit the function parameter in the argument.

declare function foo1<T>(a: T, b: T);
foo1((s: string) => { }, x => { x.blah }); // x is any, contextual typing did not take place

declare function foo2<T>(a: (x: T) => void, b: (x: T) => void);
foo2((s: string) => { }, x => { x.blah }); // x is string, contextual typing did take place

[JsonFreeman]

Note that this may make it hard to be smarter about determining whether a given expression is context sensitive.

[mhegazy]

Since we have not gotten any concrete feedback on this, i am inclined to leave the current rule the way it is.

[JsonFreeman]

I am not so sure that we haven't gotten feedback on this. We get a lot of nebulous type argument inference bug reports, and some of them may in fact be related to this. We can sit on it, but I don't think it matches user expectations.

[RyanCavanaugh]

Invoking the 1-year clause on this one

[JsonFreeman]

Reading this again, over a year later, I have to say I'm not surprised that nobody cared!