Wrong inference from function return argument

[AlexGalays]

TypeScript Version: 2.2.0-dev.20161221

Code

type SomeParams<A> = { a: A, enter: (a: A) => void }

function canYouInferThis<A>(fn: () => SomeParams<A>): { aa: A } {
  return { aa: fn().a }
}

const result = canYouInferThis(() => ({ a: { bla: 33 }, enter: a => undefined }))
result.aa.bla // Doesn't compile

Expected behavior:
The A parameter should be inferred to be { bla: number }. It seems completely unambiguous to me.
Failing that, I would expect a warning about ambiguous inferred types.

Actual behavior:
The type of A is silently inferred to be {}

[DanielRosenwasser]

Something that was a little easier for me to analyze:

interface Foo<A> {
    a: A;
    b: (x: A) => void;
}

declare function canYouInferThis<A>(fn: () => Foo<A>): A;

const result = canYouInferThis(() => ({
    a: { BLAH: 33 },
    b: x => { }
}))

result.BLAH;

[AlexGalays]

Any news? Could this still make it for 2.4?

[weswigham]

Right - so this is caused by how we currently perform contextual typing and inference. When we attempt to find the type of the first parameter of x => {} we get its contextual type - which is informed by the inference context for the surrounding signature. When we perform this instantiation, we have not created any inferences for A yet, so A is assigned its default inference, then assigned to the x parameter permanently. When we than actually dive into the object literal to make inferences, we see that the inference for A is already fixed to {}, and so ignore the "better" inference target.

I think the "skip context sensitive" pass we perform is generally supposed to alleviate this (so noncontextual inferences like the one here are performed first), but the issue arises because the pass effectively skipped - the entire top-level arrow () => ({..}) is marked as context sensitive, so we never dive into its return to get the potential context-insensitive inference from it.

Now, as it turns out, this is a fixable problem! We need only continue building a type in SkipContextSensitive checking mode, ignoring just the individually context-sensitive parameters (or simply all parameters - I don't really believe it matters since they should get picked up in the second pass provided they're not fixed in the first), rather than ignoring the entire signature.