Make functions generic when contextually typed by a generic signature

[zpdDG4gta8XKpMCd]

type Foo = (one: string) => number;

function fooOver() : Foo {
    return one => parseInt(one); // <-- one is string
}

type Bar = <a>(one: string) => a;

function barOver() : Bar {
    return one => parseInt(one); // <-- one is god knows what
}

[RyanCavanaugh]

Technically this is according to per spec (I know, your favorite response), but I think we should do better here.

Section 4.2.3 (https://github.com/Microsoft/TypeScript/blob/master/doc/spec.md#423-contextually-typed-expressions) says

In the body of a function expression or arrow function that has no return type annotation, if the function expression or arrow function is contextually typed by a function type with exactly one call signature, and if that call signature is non-generic, return expressions are contextually typed by the return type of that call signature.

We already said that we should contextually type parameters when type annotations are present somewhere --- no reason we shouldn't contextually type using the non-generic parameter positions or non-generic return positions.

[ahejlsberg]

@RyanCavanaugh There is no easy way to tell whether a particular type references a type parameter and I honestly think that we either contextually type all parameters or none. Anything in between just gets even more confusing.