Code completion doesn't work when using function overloading

[Lenne231]

TypeScript Version:

1.8.0

Code

interface A {
    name: string;
    age: number;
}

interface AExtension {
    name?: string;
    age?: number;
}

interface B {
    key: string;
    value: boolean;
}

interface BExtension {
    key?: string;
    value?: boolean;
}

function extend(base: A, extension: AExtension);
function extend(base: B, extension: BExtension);
function extend<T>(base: T, extension: any) {

}

const b : B = { key: '...', value: true };

extend(b, { key: '' });

Expected behavior:
Code completion for second parameter of extend shows properties of BExtension.

Actual behavior:
Code completion for second parameter of extend shows properties of AExtension.

[DanielRosenwasser]

#6405 is extremely related, though I think it is easier to tackle than this.

[mhegazy]

the issue here is that we do not do partial overload resolution. ideally you would know that non of the signatures match, and that you are in the middle of typing the second argument, so you would remove this from the list of arguments and try to do a partial resolution on the first argument only. the second overload should be picked up at this point as it would be considered "better" than the first one if we only consider the first argument.
unfortunately this is not a small change, it will require some rewriting for some of the overload resolution logic, in the core of the type system.

[eggers]

I think that this is a related issue:

interface Converter {
	foo<T>(dataFunction: () => T|T[]): ArrayWrapper<T>;
	foo<T>(dataFunction: () => T): Wrapper<T>;
}

interface Wrapper<T> {
	bar(): Wrapper<T>;
	value(): T;
}

interface ArrayWrapper<T> extends Wrapper<T[]> {
	bar(): Wrapper<T[]>;
	bar(first: true): Wrapper<T>;
}


let converter: Converter;

converter.foo(() => 2).value().toPrecision();  // Property 'toPrecision' does not exist on type 'number[]'.
converter.foo(() => [2]).bar(true).value().toPrecision();
converter.foo(() => Math.random() > 0.5 ? [2]: 2).bar(true).value().toPrecision();

I've been trying without success to find some kind of declaration that satisfies all three cases.

[RyanCavanaugh]

Seems to work now