Promise of type `{ }` ignored when nested

[NoelAbrahams]

TypeScript Version: 2.1.4

Code

function getDate(): Promise<Date> {
    return Promise.resolve(new Date());
}

function getFoo(): Promise<{}> {
    return Promise.resolve({});
}

function doFoo() : Promise<number> {

    // Error: Type 'Promise<Date>' is not assignable to type 'Promise<number>'.
    return (
        getDate()
            .then(() => {

                return (
                    getFoo()
                        .then(() => {

                            return 10;
                        })
                );
            })
    );
}

Expected behavior:

No compilation error

Actual behavior:

Compiler error: Type 'Promise<Date>' is not assignable to type 'Promise<number>'.

Futher Notes
Changing getFoo to return any other value, e.g. function getFoo(): Promise<void> fixes the compilation error.

[aluanhaddad]

It looks like the order of the overloads of .then in lib.es2015.promise.d.ts are wrong.
I could be wrong but my understanding is that they need to be declared in decreasing order of specificity. When I change this, it fixes the error.
Here is a more minimal repro (note that no error is reported but that the type of result is wrong).

function getFoo(): Promise<{}> {
    return Promise.resolve({});
}

function doFoo(): Promise<number> {
    const result = getFoo()
        .then(() => {

            return 10;
        });
    return result; // Result has type Promise<{}> should be Promise<number>
}

[NoelAbrahams]

Aluan Haddad (@aluanhaddad), I might even suspect that the non-generic overload of then is redundant and should be removed.

[aluanhaddad]

Noel Abrahams (@NoelAbrahams)
Yes I think you are right. Regardless the overload order should be fixed because it is always going to pick the wrong one for cases where T is assignable to TResult as is the case when TResult is {} for any T.