Dissallow same parameter signature in overloads

[tinganho]

I think the below overloads are ambiguous:

namespace Greet {
    export function sayHi(): number
    export function sayHi(): string
    export function sayHi(): string | number {
        if (Math.random() > 0.5) {
            return '';
        }
        else {
            return 1;
        }
    }
}

// What 
typeof Greet.sayHi(); // What is the type?

Since, we are selecting a return type based on the parameter signature. But, what if the parameter signature is the same on multiple overloads? Nowadays, if the checker cannot find an appropriate overload it takes the first one. I think this is quite an unsafe approach. In the above example, it is clear that sayHi() cannot be narrowed to either string or number based on parameter signature selection, since there is only one parameter signature (), and thus should have the return type string | number only.

What I propose, is to error on the overload that has the same parameter signature:

namespace Greet {
    export function sayHi(): number // Error: Multiple same parameter signature on overload
    export function sayHi(): string // Error: Multiple same parameter signature on overload
    export function sayHi(): string | number {
        if (Math.random() > 0.5) {
            return '';
        }
        else {
            return 1;
        }
    }
}
``

[alitaheri]

There is something else involving generics:

function sayHi<T extends string>(): T;
function sayHi<T extends object>(): keyof T;
function sayHi(): string { ... }

it can match conditionally by type even without using inference:

sayHi<'a'>(); // 'a'
sayHi<{b: number}>(); // 'b'

If the compiler should enforce that it should keep this behavior intact. Generic constraints contribute identity to the signature.

In other words it should only complain when it sees indistinguishable overloads (overloads ONLY different in their return type). Not having this rule enforced haven't got me into trouble so far though.

[tinganho]

I was thinking about type parameter as well, though didn't give an example on it.

paramater signature = type parameter signature + value parameter signature 

[tinganho]

I think this one is also required for #6606. Since, the following expression is ambiguous:

typeof Greet.sayHi();

[gcnew]

#13225 is in a similar vein.

[HerringtonDarkholme]

Just for your information, the proposed behavior is implemented in pre TS1.1. But it is removed in later releases.

http://stackoverflow.com/questions/25022331/overloads-cannot-differ-only-by-return-type

Also, the spec disallows same parameter signature in ambient function declaration.

[mhegazy]

Duplicate of #13225