Deeper type inference in context sensitive arguments

[ahejlsberg]

Fixes #1181.

Previously, context sensitive arguments (arguments containing function expressions that are subject to contextual typing) would be completely ignored in the first round of type inference. With this change we instead infer from all arguments in the first round, but treat context sensitive function expressions as wildcards from which no inferences are made.

interface Computed<T> {
    read(): T;
    write(value: T);
}

function foo<T>(x: Computed<T>) { }

var s: string;

foo({
    read: () => s,
    write: value => s = value
});

This example would previously infer {} for T because the object literal argument was excluded from the first round of type inference. We now include the argument in the first round, but treat the context sensitive arrow function value => s = value as a wildcard. That allows us to infer string for T from the (non-sensitive) arrow function () => s. In the second round of inference we then end up fixing T and assigning the inferred type string to the value parameter.

This also fixes a bug related to #1648 where the contextualMapper argument wasn't being propagated into a parenthesized expression, causing us to leak a type parameter.

[DanielRosenwasser]

Make this comment First infer from all arguments, but use wildcards for all context sensitive expressions.

The "but" actually would really help to point out that this is a special case.

[DanielRosenwasser]

It is strange that we only have 2 affected baselines, and only in one of them did we see that leaked type parameter issue. This change really needs more test coverage.

[JsonFreeman]

Please add tests for both of these changes.

[JsonFreeman]

I'm fine with this code change, but it needs tests.
Also, I do think that the related issues we discussed should be addressed soon.

[JsonFreeman]

👍