Contextual type inference fails in surprising case

[bterlson]

TypeScript Version: 3.1.0-dev.20180719
Code

type R = {
  a: (x: number) => void;
  b: (x: string) => void;
};

type O = {
  on<P extends keyof R>(x: P, callback: R[P]): void;
};

declare var x: O;
x.on('a', a => {}); // not contextually typed.

Expected behavior:
Contextually type a to number.

Actual behavior:
A is not contextually typed, while signature help gives the correct answer.

Playground Link: here

[ahejlsberg]

This is working as intended (but you could argue a design limitation). We only contextually type function expression parameters when the parameter type is known to be a function type before instantiation. In your example, we would have to fix P following inference for the first argument and then P during inference for the second argument, but we don't do that currently. I suppose you could argue we should if all properties addressable by R[P] are function types, but that would be a new feature.

[ahejlsberg]

BTW, it works if you write it like this (because inference now knows the contextual type is a function type):

type R = {
  a: number;
  b: string;
};

type O = {
  on<P extends keyof R>(x: P, callback: (x: R[P]) => void): void;
};

declare var x: O;
x.on('a', a => {}); // Contextually typed.

[bterlson]

I see @ahejlsberg, thanks. Consider this a feature request then 😊

Thank you so much for pointing out it works if the callback is "obviously" a function type, I think I can make this work for my scenario with the following tweak to the OP:

type R = {
  a: (x: number) => void;
  b: (x: string) => void;
};

type O = {
  on<P extends keyof R>(x: P, callback: (...args: Params<R[P]>) => void): void;
};

type Params<F> = F extends (... args: infer T) => any ? T : never;

declare var x: O;
x.on('a', a => {}); // yay is contextually typed now!

[typescript-bot]

Automatically closing this issue for housekeeping purposes. The issue labels indicate that it is unactionable at the moment or has already been addressed.