Overloaded Function Signature: Can't delegate to function with same signature

[tp]

TypeScript Version: 2.2.1

Code

interface NumberOption {
    returnNumber: true;
}

interface NoNumberOption {
    returnNumber?: false;
}

function eitherOuter(option: NumberOption): number;
function eitherOuter(option: NoNumberOption): string;
function eitherOuter(option: NumberOption | NoNumberOption = {}): string | number {
    // return eitherInner(option); // Does not compile
    if (option.returnNumber === true) {
        return eitherInner(option);
    } else {
        return eitherInner(option);
    }
}

function eitherInner(option: NumberOption): number;
function eitherInner(option: NoNumberOption): string;
function eitherInner(option: NumberOption | NoNumberOption = {}): string | number {
    if (option.returnNumber) {
        return 1;
    } else {
        return 's';
    }
}

const n = eitherOuter({ returnNumber: true });
const s1 = eitherOuter({ returnNumber: false });
const s2 = eitherOuter({});

Expected behavior:
I would expect to be able to delegate from eitherOuter to eitherInner without any special annotations.

Actual behavior:
Delegating from eitherOuter to eitherInner is not possible, instead the simplest workaround I was able to find was to write an if statement, which had the same statement in both branches.

[aluanhaddad]

Type Checking the implementation of eitherOuter fails because there is no overload declaration of eitherInner that takes NumberOption | NoNumberOption. It looks at the first declared overload and rejects it since it cannot except the union type. It rejects the second declared overload for the same reason.

Simplest solution - remove type annotation on eitherOuter's implementation. (still perfectly type safe)

function eitherOuter(option: NumberOption): number;
function eitherOuter(option: NoNumberOption): string;
function eitherOuter(option = {}): string | number {
  return eitherInner(option); // Compiles
}

Alternate solution (if you want everything to have an explicit type, even where already typesafe and any free without one) - add an overload declaration to eitherInner

function eitherInner(option: NumberOption): number;
function eitherInner(option: NoNumberOption): string;
function eitherInner(option: NoNumberOption | NumberOption): string | number;
function eitherInner(option: NoNumberOption | NumberOption = {}): string | number {
  if (option.returnNumber) {
    return 1;
  } else {
    return 's';
  }
}

[mhegazy]

I am not seeing any errors on the latest drop. closing as fixed. please reopen if this is not the case.