Callback function type checks don't work with overloads

[falsandtru]

TypeScript Version:

master

Code

interface F {
  (g: () => void): number; // if this line is removed, tsc gives a correct error.
  (g: (i: (p: number) => number) => void): number;
}
var f: F;
f(i => h(i));
function h(i: (p: string) => string): string {
  return i('');
}

Expected behavior:

index.ts(6,10): error TS2345: Argument of type '(p: number) => number' is not as signable to parameter of type '(p: string) => string'.
  Types of parameters 'p' and 'p' are incompatible.
    Type 'string' is not assignable to type 'number'.

Actual behavior:

pass

[RyanCavanaugh]

I believe this is a duplicate of #598

[falsandtru]

I think this is a different case because if finished callback returns a not void type, tsc throws an error correctly.

interface KnockoutElement<T> {
  // Getter
  (): T;
  // Setter
  (value: T): void;
}

function readFile(finished: (contents: string) => string) { /*... */ }
var ko: KnockoutElement<number>;
readFile(ko); // throw an error correctly.

Additionally, my filed case doesn't depend parameters.

interface F {
  (g: () => void): number; // if this line is removed, tsc gives a correct error.
  (g: (i: () => number) => void): number;
}
var f: F;
f(i => h(i));
function h(i: () => string): string {
  return i();
}

So I think TypeScript should add a test of this case when fix this issue.

[RyanCavanaugh]

You're right, this is different. The problem is that this code appears to be valid and it's not at all clear how to make it invalid.

interface F {
  (g: () => void): number;
  (g: (i: (p: number) => number) => void): number;
}
var f: F;
f(g => h(g));
function h(i: (p: string) => string): string {
  return i('');
}

The code says that h takes a parameter i and invokes it with a string. f has two overloads -- either taking a callback of zero arguments, or a callback of one argument. It's valid to ignore parameters (i.e. accept fewer arguments than are provided), so the first overload we try is the one that works -- in fact, we never even typecheck against the second overload at all!

This code should really be written as

interface F {
  (g: (i: (p: number) => number) => void): number;
}

or at the very least

interface F {
  (g: (i: () => number) => void): number;
  (g: () => void): number; // if this line is removed, tsc gives a correct error.
}

but it's unclear how we even detect these problems.

[falsandtru]

I fixed my code a little.

- f(g => h(g));
+ f(i => h(i));

[falsandtru]

@RyanCavanaugh Could you fix this?

[RyanCavanaugh]

@falsandtru I'm not sure what you mean?

[falsandtru]

@RyanCavanaugh Could you fix this problem? I feel this is a bug.

[RyanCavanaugh]

Unfortunately it's a design limitation (we choose the first available overload successfully) with no clear fix.

There's no reason to write a set of overloads that way, though, so the fix on your end should just be to do one of the suggested rewrites. Some advanced linting rule might be able to detect a set of "bad" signatures.

[falsandtru]

I see, thanks for the answer...