Less aggressive contextual signature instantiation

[ahejlsberg]

With this PR we perform less aggressive contextual signature instantiation:

declare function foo<T extends (x: string) => string>(f: T): T;

const f = foo(<U>(x: U) => x);  // <U>(x: U) => U

Previously, we'd infer type (x: string) => string for f because we'd obtain the apparent type of T and then instantiate the argument type <U>(x: U) => U in the context of that type. While not incorrect, a better course of action is to leave the argument type alone and just infer it as-is when inferring directly to a type variable. That's the change in this PR.

This change also fixes #32976 because we no longer need to check for mixin constructor types (which wasn't really a correct check to begin with).

Fixes #32976.

[weswigham]

In addition to TypeVariable, should this also be looking for Substitution (since that wraps a type variable pretty directly)?

[ahejlsberg]

Can you write an example that would depend on this?

[weswigham]

declare function foo<T extends (x: string) => string>(f: T): T;

type SubstituteOf<T> = T extends {} ? T : never;

const f = foo(<U>(x: SubstituteOf<U>) => x);  // <U>(x: U) => U

still instantiates as string on this PR.

[ahejlsberg]

No, for your example you get what you'd expect with the PR:

const f = foo(<U>(x: SubstituteOf<U>) => x);  // <U>(x: SubstituteOf<U>) => SubstituteOf<U>

The substitution type would need to be in the contextual type (i.e. the parameter's type would need to be a substitution type) for the original question you posed to make sense. I don't see how that could happen which is why I asked for an example.