Overload Signature Is Not Compatible For Inherited Type Function Parameter

[daryllabar]

TypeScript Version: 2.4.1

Code

// A *self-contained* demonstration of the problem follows...
class Animal {
    a: string;
}

class Dog extends Animal {
    b: string;
}

function test(func: (p: Dog) => any): any;
function test(func: (p: Animal) => any): any;
function test(func: (p: Animal) => any): any {

    return undefined;
}

Expected behavior:
No TS2394 Compiler error

Actual behavior:
a TS2394 Compiler error for this line:

function test(func: (p: Dog) => any): any;

Changing function definition the below resolves the compile error:

function test(func: (p: any) => any): any {

[jcalz]

This looks like intended behavior.

Since the func parameter is a callback, TS 2.4 is checking it more strictly than earlier versions.

The type of func in each overload needs to be assignable to the type of the func in the implementation. Or, from the other direction: the type of func in the implementation should be a supertype of all the types declared for func in the overloads.

Let's call (p: Dog) => any a Dog-consumer, and (p: Animal) => any an Animal-consumer. Note that every Animal-consumer is a Dog-consumer (because something that consumes animals will accept a dog), but not every Dog-consumer is an Animal-consumer (because something that consumes dogs might not accept, say, a cat). That means that Dog-consumer is a supertype of Animal-consumer. Since one overload takes a Dog-consumer, and the other takes an Animal-consumer, the implementation should take a supertype of these: Dog-consumer.

That is:

function test(func: (p: Dog) => any): any;
function test(func: (p: Animal) => any): any;
function test(func: (p: Dog) => any): any {  // no error now

[daryllabar]

Ahh, so I confused a "callback parameter" with the return type. Since func is a call back function, it's type is a call back parameter?

Side note, I would expect this to give a different error

function test(func: (p: Dog) => any): any;
function test(func: (p: Animal) => any): any;
function test(func: (p: Animal|Dog) => any): any {

because func: (p:Animal) doesn't accept a Dog.

Never-mind, it's the same issue and I see that now. This is what I want:

function test(func: (p: Dog) => any): any;
function test(func: (p: Animal) => any): any;
function test(func: ((p: Animal) => any) | ((p:Dog) => any)): any {

[jcalz]

Note that func: ((p: Animal) => any) | ((p:Dog) => any) is essentially equivalent to func: ((p:Dog) => any). If you use the union, you'll find that you can't actually call func() on anything directly (see #14107), so the latter is probably preferable.

[daryllabar]

@jcalz I noticed that. Ended up with something like this:

function test<T,A extends Dog   >(animal:A, func: (p: A) => T): T;
function test<T,A extends Animal>(animal:A, func: (p: A) => Foo<T>): Foo<T>;
function test<T,A extends Animal>(animal:A, func: (p: A) => T|Foo<T>): T|Foo<T> {
    return func(animal);
}

I've included Foo<T> just so it would make sense as to why the overload would be defined

I'm guessing that is the best way?

[RyanCavanaugh]

Crosspost reference https://stackoverflow.com/questions/45087264/how-to-cleanly-write-a-typescript-function-with-different-callback-overload-para for anyone who ends up here