More flexible handling of circular types with "typeof function" inference

[finom]

🔍 Search Terms

"is referenced directly or indirectly in its own type annotation.ts(2502)"
"self-referencing types"
"circular types"
...

✅ Viability Checklist

• 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 isn't a request to add a new utility type: https://github.com/microsoft/TypeScript/wiki/No-New-Utility-Types
• This feature would agree with the rest of our Design Goals: https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals

⭐ Suggestion

I would like to be able to infer type of a function A that calls another function B, returning its value, relying on parameters of function A (not sure if the description is good, see the code snippet).

📃 Motivating Example

function foo(arg: Parameters<typeof bar>[0]) {
  return arg;
}

function bar(arg: string) {
  return foo(arg);
}

The code above, obviously, would be unable to infer return type. But hypothetically it's possible to extract its parameters.

💻 Use Cases

More flexible type inference. Currently there is no workaround for this problem. My personal use-case is to produce less types while I define service and controller for my back-end. I've simplified the code to remove unnecessary types.

class ReportController {
  static createReport(body: { reportName: string }) {
    return ReportService.createReport(body);
  }
}

class ReportService {
  static createReport(body: Parameters<typeof ReportController.createReport>[0]) { // body is "any" + error
    // ...
  }
}

At this case body is clearly { reportName: string } but because of the restriction I'm not able to use it. At this example I can move body to a type variable but in practice it's more complicated because of other inferences and I would need to define body type for each controller method outside of the classes.

[fatcerberus]

I would like to be able to infer type of a function A that calls another function B, returning its value, relying on parameters of function A (not sure if the description is good, see the code snippet).

I'm not 100% sure, but based on your description I think you're looking for #40179?

[finom]

@fatcerberus I think I'd still need to refer to the function type: paramsof typeof bar what would cause the same problem.

[ahejlsberg]

This is sort of a bug, but really more of a possible improvement. At any rate, during type inference in the instantiation of the Parameters<T> conditional type, we attempt to resolve the return type of bar without really needing to, which leads to a circularity. It's a pretty easy fix, I'll put up a PR.

[finom]

@ahejlsberg that's amazing! Honestly, I didn't expect to get this reaction seeing so many issues at this repo ❤️

[finom]

@ahejlsberg that's perfect! Thank you! I think many people would be happy to show their appreciation to you by sponsoring but unfortunately your sponsoring page is not set up. This update changes a lot in my code and solves a problem that I was having for very long time. Sorry for delayed reply, I didn't know how TS versioning works and just installed the PR version ❤️

[finom]

@ahejlsberg I'm doing some tests but still getting similar problems. Could you also check the following and more complex example:

function withSchmuck<T, R>(arg: T, handler: (arg2: T) => R) {
  console.log(arg);
  return handler;
}

const foo = withSchmuck('hello', (arg) => {
  return bar(arg);
});

function bar(arg: Parameters<typeof foo>[0]) {
   console.log(arg);
}

The arg of bar should have type of string but TS says this is the same error as I got before. As in the previous case, nothing is trying to infer the return type, only arguments.