Overloaded function calling overloaded function

[jmezzera]

TypeScript Version: 3.9.2

Search Terms:

Expected behavior:
Being able to call an overloaded function with the union of types derived from the overloading of another function. In the provided example, in C2Wrong, param can be either A or B (nothing else), and method method on child accepts both A or B. Is there any reason why I should check myself? Doing so results in nonsense redundant code C2Ok.

Actual behavior:
The compiler complains about the types.

Related Issues:

Code

class A {
    prop1: string;
    constructor(prop1: string){
        this.prop1 = prop1
    }
}

class B {
    prop2: string;
    constructor(prop2: string){
        this.prop2 = prop2
    }
}

interface i1 {
    method(a: A): number;
    method(b: B): number;
}

class C1 implements i1 {
    method(a: A): number;
    method(b: B): number;
    method(param: A | B): number {
        return 1;
    }
}

interface i2 {
    method(a: A): number;
    method(b: B): number;
}

class C2Wrong implements i2 {
    child: i1 = new C1();
    method(a: A): number;
    method(b: B): number;
    method(param: A | B): number {
        return this.child.method(param);
    }
}
class C2Ok implements i2 {
    child: i1 = new C1();
    method(a: A): number;
    method(b: B): number;
    method(param: A | B): number {
        if (param instanceof A){
            return this.child.method(param);
        }
        return this.child.method(param);
    }
}

Output

"use strict";
class A {
    constructor(prop1) {
        this.prop1 = prop1;
    }
}
class B {
    constructor(prop2) {
        this.prop2 = prop2;
    }
}
class C1 {
    method(param) {
        return 1;
    }
}
class C2Wrong {
    constructor() {
        this.child = new C1();
    }
    method(param) {
        return this.child.method(param);
    }
}
class C2Ok {
    constructor() {
        this.child = new C1();
    }
    method(param) {
        if (param instanceof A) {
            return this.child.method(param);
        }
        return this.child.method(param);
    }
}

Compiler Options

{
  "compilerOptions": {
    "noImplicitAny": true,
    "strictNullChecks": true,
    "strictFunctionTypes": true,
    "strictPropertyInitialization": true,
    "strictBindCallApply": true,
    "noImplicitThis": true,
    "noImplicitReturns": true,
    "alwaysStrict": true,
    "esModuleInterop": true,
    "declaration": true,
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true,
    "moduleResolution": 2,
    "target": "ES2017",
    "jsx": "React",
    "module": "ESNext"
  }
}

Playground Link: Provided

[DanielRosenwasser]

Seems like a duplicate of #1805

[jmezzera]

Seems like. My bad!