Wrong overload selected on function when passed a callback annotated with a type with multiple optional properties

TypeScript Version: 2.7.0-dev.20171128

Code

This issue was first noticed in code that uses LoDash with the typings from DefinitelyTyped. It seems to manifest only in a very specific set of circumstances. The following code sample is as minimal a reproduction as I could find.

let _: LoDashStatic;

interface LoDashStatic {
  mapValues<T extends object, TResult>(
    obj: T,
    callback: (value: T[keyof T]) => TResult
  ): { [P in keyof T]: TResult };

  mapValues<T extends object>(obj: T, iteratee: object): { [P in keyof T]: boolean };
}

interface Item {
  key?: string;
  bar?: number;
}

interface Collection {
  [key: string]: Item;
}

const source = { foo: { bar: 42 } };
let items: Collection = _.mapValues(
  source,
  (v: Item) => v
);

Note that the correct overload is selected when any of the following changes are made to the above code:

• Remove the type annotation on the callback: (v) => v instead of (v: Item) => v
• Remove the nested optional property: { foo: {} } instead of { foo: { bar: 42 } }
• Remove the unused optional property: interface Item { bar?: number; } instead of interface Item { key?: string; bar?: number; }
• Annotate the source collection: const source: Collection = { foo: { bar: 42 } }; instead of const source = { foo: { bar: 42 } };

Expected behavior:

Compiles without issue.

Actual behavior:

error TS2322: Type '{ foo: boolean; }' is not assignable to type 'Collection'.
  Property 'foo' is incompatible with index signature.
    Type 'boolean' is not assignable to type 'Item'.

Start with the minimal TypeScript reproduction in the issue and investigate overload resolution for the annotated callback, optional properties, and inferred source type. Done means the sample compiles without the TS2322 error and selects the callback overload rather than the object-iteratee overload.