Support "jump to" for literal record keys

[donaldpipowitch]

Suggestion

🔍 Search Terms

• jump to record key

✅ 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

Record keys should support "Jump to definition" actions.

📃 Motivating Example

type Something = { field: string };

type Somethings<Keys extends string> = Record<Keys, Something>;

type ContainerOfSomethings = Somethings<'a' | 'b'>;

const container: ContainerOfSomethings = {
    a: { field: 'a' },
    b: { field: 'b' }
};

console.log(container.a);
                     // ^---- "Jump to" should bring me to line 5 where 'a' is listed

Playground Example

💻 Use Cases

Enhance Developer Experience.

[suica]

In fact, sometimes it can be really tricky to track for the definition of key. Maybe we can only support a portion of them. For example, the original Record type constructor.

Naive case

type A = 'a' | 'b';
declare const test: {[x in A]: string}
test.a

Expected to show type A.

Simple case

type A = 'a' | 'b';
type C = 'a' | 'c';
declare const test: {[x in A | C]: string}
test.a

Expected to show a definition list of length 2, including type A and type C.

Complicated case

type A = 'a' | 'b';
type C = 'a' | 'c';
declare const test: {[x in A extends C ? A : C]: string}
test.a

Expected to show the definition is from type A. But can be not very easy to implement in few lines of code.

[suica]

There is a hard-coded implementation of the idea.
One the tricky problems is that in fact we cannot get declaration at a in rec.a (as there is no declaration field in the symbol, unlike a regular object). Type literals are just not symbols, hence TypeScript only defined what's declaration for symbols.
So, in the implementation I searched both the AST level and the type level to find the exact so-called "declaration".
It's really awkward.
Looking for feedbacks! :)

[Andarist]

There is a good overlap between this issue and those two: #49033 , #45549