Generics use last rather than first matching overload

[SamPruden]

TypeScript Version: 2.7.0-dev.20171124

Code

class Foo {
    bar(): 1;
    bar(): 2;
    bar(): number {
        return 1;
    }
}

interface WithBar<R> {
    bar(): R;
}

function test<R>(a: WithBar<R>): R {
    return a.bar();
}

const foo = new Foo();
const n1 = foo.bar(); // Has type 1
const n2 = test(foo); // Has type 2

Expected behavior:
n1 and n2 have the same type, namely 1.

Actual behavior:
n2 gets the incorrect type 2. It seems that R is taken from the last matching overload, rather than the first.

I don't know if there's some detailed spec doc somewhere that I could use to confirm that this is a bug rather than a weird design, but it's definitely undesirable to me.

[mhegazy]

The assumption here is that the last signature is more general, and thus leads to better inferences.

[typescript-bot]

Automatically closing this issue for housekeeping purposes. The issue labels indicate that it is unactionable at the moment or has already been addressed.