[API] Ability to check if a parameter is being passed to const type parameter

🔍 Search Terms

const type parameter

✅ 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

Hi from ts-api-utils.

We'd like to be able to check if an expression, passed as an argument of a call expression, is in a "const context". Checking for as const is fairly trivial as we can just search up the syntax tree, but checking for const type parameters seems impossible without using TypeScript internals.

With code examples:

We can currently check if foo is in a "const context" here fairly trivially:

const test1 = { foo: 1 } as const;

But can't do the same for foo in this example:

declare const fn: <const A>(param: A) => unknown;
const test2 = fn({ foo: 2 });

Proposal

Ideally, we would like an officially supported way to make such a check.

We currently have a PR in progress that works using ts internals, but we'd prefer not to rely on ts internals.

📃 Motivating Example

N/A

💻 Use Cases

1. What do you want to use this for?
   determining whether a type is readonly
   https://github.com/eslint-functional/eslint-plugin-functional/issues/827

2. What shortcomings exist with current approaches?
   There doesn't seem to be anyway official way to do this

3. What workarounds are you using in the meantime?
   Use ts internals

Commencez par reproduire l’exemple de paramètre de type const et examiner la TypeScript compiler API ainsi que l’approche interne existante utilisée par ts-api-utils PR #519. Le travail est considéré comme terminé lorsqu’une API officiellement prise en charge peut déterminer si une expression d’argument se trouve dans un contexte const, y compris le cas d’utilisation readonly-type, sans dépendre des composants internes de TypeScript.