Report better errors on return expressions for immediately-assigned functions

Suggestion

🔍 Search Terms

return type label:"Domain: Error Messages"

✅ Viability Checklist

My suggestion meets these guidelines:

• This wouldn’t be a breaking change in existing TypeScript/JavaScript code
• This wouldn’t change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn’t a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
• This feature would agree with the rest of TypeScript’s Design Goals.

⭐ Suggestion

Error reporting for mismatches between a functions return type and what is being returned by a particular return statement should be consistently reported a the location of the offending return.

📃 Motivating Example

TypeScript Playground

type Foo = (input: string) => number;

const foo: Foo = (input) => {
  switch (input) {
    case "1":
      return 1;
    case "2":
      return "2";
    default:
      return Infinity;
  }
}

The following error is reported on the declaration of foo.

const foo: Foo
Type '(input: string) => number | "2"' is not assignable to type 'Foo'.
  Type 'number | "2"' is not assignable to type 'number'.
    Type 'string' is not assignable to type 'number'.(2322)

const bar = (input: string): number => {
  switch (input) {
    case "1":
      return 1;
    case "2":
      return "2";
    default:
      return Infinity;
  }
}

The following error is reported on return "2":

Type 'string' is not assignable to type 'number'.(2322)

💻 Use Cases

In the second example it’s much easier to see where the problem is. In larger functions for more `returns it can be even hard to pin down which one is causing the issue. These two examples are very similar and I would expect the same error to be reported for each.

[andrewbranch]

I don’t think we would ever get rid of the error where it’s placed in the first example. The fundamental assignability check there is the whole function to Foo, whereas in the latter, the assignability check is the return type to number. I would argue that being able to follow the logic of these comparisons is an acquired skill, but is actually useful and important to users as they try to work out increasingly complicated errors. However, I totally agree that once the error elaboration gets down to the "2" comparison, it can be hard to find what it’s talking about if the function is any bigger. It seems like there might be a good opportunity for a related error span here. /cc @DanielRosenwasser, as error reporting is his favorite topic.

[kevinbarabash]

Yeah, when to report what kind of error can be pretty contextual. Explicitly including the return value even when using the Foo type gives me the behavior I want in this case. It’s a little extra typing so not a big deal.