refactoring for extracting return type of a function

Search terms

refactoring extract return type function method interface inferred

Suggestion

A new refactoring for function expressions that extracts the return type of the function as an interface or type.

Use Cases

Imagine a complex function that combines many types of data into a complex object. Compiler can infer the return type, but writing it out by hand takes time. Type needs a name when you want to use it elsewhere in the code (for example as a parameter type for another function).

Examples

Imagine A, B, C, D are non trivial types. (e.g. objects with many properties)

before:

function fooFunc(a: A, b: B, c: C, d: D) {
  return {
    ...a,
    ...b,
    foo: {...c, d}
  }
}

after:

type FooFuncReturn = A & B & { foo: C & D }
// or when possible an interface type with would be even better

function fooFunc(a: A, b: B, c: C, d: D): FooFuncReturn {
  return {
    ...a,
    ...b,
    foo: {...c, d}
  }
}

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, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

The issue names no files, tests, or entry points. Start by locating TypeScript's existing refactoring infrastructure, then define how the requested return-type extraction should handle the example's type and interface forms; done means the refactoring works for the stated function-expression use case with coverage for its output.