Type inference algorithm depends on function argument order? (bug?) #17237

function f(a: A, b: B, c: C) {
    // ...
}

function f(a: A, c: C, b: B) {
    // Body is completely identical
}

// test1 + leftJoin1
//
// Both these functions compile great!
//
export function leftJoin1<s, a extends object>(
        q: Q<s>,
        s: (q: Q<Inner<s>>) => MakeCols<Inner<s>, a>,
        pred: (p: MakeCols<s, a>) => Col<s, boolean>
    ): LeftCols<s, a> {
    q;
    pred;
    throw new Error("not implemented");
}
export function test1<s>(q: Q<s>) {
    leftJoin1(q,
        q => select(q, addressTable),
        address => stub(address.name)  // Works fine!  address: MakeCols<s, Address>
    );
}

// test2 + leftJoin2
//
// Swap the parameters and now there is an error!
//
export function leftJoin2<s, a extends object>(
        q: Q<s>,
        pred: (p: MakeCols<s, a>) => Col<s, boolean>,
        s: (q: Q<Inner<s>>) => MakeCols<Inner<s>, a>
    ): LeftCols<s, a> {
    q;
    pred;
    throw new Error("not implemented");
}
export function test2<s>(q: Q<s>) {
    leftJoin2(q,
        address => stub(address.name),  // Error here!  address: MakeCols<s, {}>
        q => select(q, addressTable)
    );
}

// --------------------------------------------------------------------

export class Q<s> {
    private constructor() { }
    "Q": Q<s>;
    s: s;
}

export interface Table<a> {
    "Table": Table<a>
    a: a;
}

export class Inner<s> {
    private constructor() { }
    "Inner": Inner<s>;
    s: s;
}

export type MakeCols<s, T extends object> = {
    [P in keyof T]: Col<s, T[P]>;
}

export class Col<s, a> {
    private constructor() { }
    "Col": Col<s, a>;
    private s: s;
    private a: a;
}

export type LeftCols<S, A> = {
    [P in keyof A]: Col<S, A[P] | null>;
}


export interface Address {
    readonly name: string;
    readonly city: string;
}

export const addressTable = declareTable<Address>("address");

export function declareTable<a>(tableName: string): Table<a> {
    tableName;
    throw new Error("not implemented");
}

export function select<s, a extends object>(q: Q<s>, table: Table<a>): MakeCols<s, a> {
    q;
    table;
    throw new Error("not implemented");
}

export function stub<s, a>(e: Col<s, a>): Col<s, boolean> {
    e;
    throw new Error("not implemented");    
}