[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

Start by reproducing the const type parameter example and reviewing the TypeScript compiler API and the existing internal approach used by ts-api-utils PR #519. Done means an officially supported API can determine whether an argument expression is in a const context, including the readonly-type use case, without relying on TypeScript internals.