Type inference error when using type parameters as constraints

[spikefoo]

When compiling the following code: (the function call takes a 0-argument function and returns its result)

type NoArgsFn<T> = () => T;

function call<T, Fn extends NoArgsFn<T>>(fn: Fn): T {
  return fn();
}

let result: number = call(() => 1);

I get the following incorrect error: (on the last line)

try.ts(7,5): error TS2322: Type '{}' is not assignable to type 'number'.

The following workaround, adding an unused dummy argument of type T to the function, avoids this error:

type NoArgsFn<T> = () => T;

function call<T, Fn extends NoArgsFn<T>>(fn: Fn, dummy: T): T {
  return fn();
}

let result: number = call(() => 1, -1);

[mhegazy]

duplicate of #7234

[malibuzios]

Hi, I believe the problem seems to be that type argument inference isn't 'smart' enough here to infer R from the function type () => R, which involves a reference to a generic parameter.

(I simplified the example a bit)

function call<R, F extends () => R>(func: F): R {
  return func();
}

let result: number = call(() => 1);

Despite the fact that the constraint doesn't error, It doesn't actually know how to infer R so it defaults to {}.

Another workaround is of course to use the signature () => R or its type alias directly as the type instead of as a constraint:

function call<R>(func: () => R): R {
  return func();
}

let result: number = call(() => 1);

But I'm not sure if that was the intention here.