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'.

Comienza con la reproducción mínima en TypeScript del issue e investiga la resolución de sobrecargas para el callback anotado, las propiedades opcionales y el tipo de origen inferido. Se considera terminado cuando el ejemplo compila sin el error TS2322 y selecciona la sobrecarga de callback en lugar de la sobrecarga de object-iteratee.