Type safety can be lost if an overloaded function is passed as a parameter

[Gekkio]

TypeScript Version: 2.2.1 + nightly (2.3.0-dev.20170301)

Code

declare function head(str: string): string;
declare function head<T>(arr: T[]): T;

const numberLists: number[][] = [
  [1, 2],
  [3, 4]
];

// This makes sense
const numberHeads: number[] = numberLists.map(head);

// This shouldn't compile
const stringHeads: string[] = numberLists.map(head);

// This shouldn't compile
const booleanHeads: boolean[] = numberLists.map(head);

// This shouldn't compile
const nullHeads: null[] = numberLists.map(head);

Expected behavior:

Described above in comments

Actual behavior:

All the cases compile, because the return type of all numberLists.map calls here is any[]. Reversing the order of the overloaded function declarations results in this:

• cases 3, 4 fail to compile (correct)
• case 1 fails to compile (incorrect)
• case 2 compiles (incorrect)

There are quite a lot of open issues involving function overloading, but I couldn't find one about forced any-typed return values, which are a silent killer in a codebase because even noImplicitAny doesn't catch these. I wouldn't mind if all the use sites required extra types, but in this case I don't seem to have a way of avoiding accidental loss of type safety.

[Gekkio]

Also, if I call the function using a lambda instead ( numberLists.map(x => head(x)) ), all the cases work as expected.

[mhegazy]

Please see #8397 for more details.