Repository: TypeScript
Issue: Stricter Assignability Checks for Overloaded Functions
Labels: Suggestion,Awaiting More Feedback

<!-- 🚨 STOP 🚨 𝗦𝗧𝗢𝗣 🚨 𝑺𝑻𝑶𝑷 🚨

Half of all issues filed here are duplicates, answered in the FAQ, or not appropriate for the bug tracker.

Please help us by doing the following steps before logging an issue:
  * Search: https://github.com/Microsoft/TypeScript/search?type=Issues
  * Read the FAQ, especially the "Common Feature Requests" section: https://github.com/Microsoft/TypeScript/wiki/FAQ

-->

## Search Terms

<!-- List of keywords you searched for before creating this issue. Write them down here so that others can find this suggestion more easily -->

function overload, assignability

## Suggestion

<!-- A summary of what you'd like to see added or changed -->

When a function has overloads, each with a different number of arguments, subtle bugs can occur.

My suggestion is to have extra assignability checks for overloaded methods/functions.
When assigning `A` to `B` the algorithm should be,
1. Is `A` assignable to `B` under the existing assignability rules?
1. Is `A` an overloaded function/method?
   1. If it is not, we are done.
   1. If it is, we need more checks,
      1. Does the assignable overload of `A` have the same number of arguments as `B`?
         1. If it does, we are done. (Right? Maybe?)
         1. If it doesn't, find all overloads of `A` with the same number of arguments as `B`
            1. Is each overload assignable to `B`? If it isn't, we have a compile-time error

## Use Cases

<!--
What do you want to use this for?
What shortcomings exist with current approaches?
-->

Better type safety. I've been bitten by this behaviour regarding overloaded functions/methods in the past, with far more complicated examples. My general advice to people is to avoid overloads as much as possible/at all cost.

If this hole in the type system is fixed, I may not be so averse to overloads... Or I'll probably find something else to gripe about =x

## Examples

The repro below has the following properties,
+ Each overload has a different number of arguments
+ Each overload has a different return type

```ts
function foo(a: number, b: symbol): string;
function foo(a: number): number;
function foo(a: number, b?: symbol): string|number {
  if (b == undefined) {
    return a;
  } else {
    return `a:${a},b:${String(b)}`;
  }
}

function takesNumCallback(callback: (a: number, b: number) => number) {
  const tmp = callback(1, 2);
  if (typeof tmp != "number") {
    throw new Error("wat");
  }
  console.log(1 / tmp);
}

//Allowed during compile-time
//But will throw an error during run-time
takesNumCallback(foo);
```
[Playground](http://www.typescriptlang.org/play/?ssl=1&ssc=1&pln=21&pc=23#code/GYVwdgxgLglg9mABMOcAUBDAXIsIC2ARgKYBOANIoTgM4CeRcANgJS1SkxgDmA3AFChIsBMlSYceImTa4CJUgKHR4SFOmxzpFKgH5aDQs1k0OXbgB8pCxAG9+iRDGCI0hRAF4PicABNiwFzEvix2Do6IpMRQIKRIGAKOAL6IxEw0xGERkdGxSAAG2AAkthhJ5NQlAMpmPG4sSfmJiEn8rYLgKqJQGADWxDQAcgQAwhhMTIQYEL1oEOOT0704EloKlNRrMp4AfFukofaOEAimiFD4AA6eiPMTUzNoAIyUAEwszc6uUHSXxHAuC7XACE3gARNYyGDDuFHFAABakOAAd1wxFRAFFSEjSGgwciMFBoc1WsdTsxiAA6JhwbjPRAAenOVw+bX4-AZDIAghMUcFEL5YuZbnArjAmMQALSwfDEDkMgBCICgiGR4qY50RKMQGCQZBxAqFPEi4GlMFl-B6-SGowWD1m6g+QA)

The problem here is that `foo (a : number) : number` is assignable to `(a : number, b : number) => number`, because TS assumes `foo (a : number) : number` will ignore the second argument (`b`).

However, TS is not considering the other overload that has two arguments and is expecting `b : symbol`.

## Checklist

My suggestion meets these guidelines:

* [ ] This wouldn't be a breaking change in existing TypeScript/JavaScript code
* [x] This wouldn't change the runtime behavior of existing JavaScript code
* [x] This could be implemented without emitting different JS based on the types of the expressions
* [x] This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
* [x] This feature would agree with the rest of [TypeScript's Design Goals](https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals).

Well, it would break TS code for people currently using overloaded functions/methods unsafely.