Support type inference for Symbol keys on function

Personne n'a encore pris cette issue.

### 🔍 Search Terms

symbol index closure function ts7022

### ✅ Viability Checklist

- [x] This wouldn't be a breaking change in existing TypeScript/JavaScript code
- [x] This wouldn't change the runtime behavior of existing JavaScript code
- [x] This could be implemented without emitting different JS based on the types of the expressions
- [x] This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
- [x] This isn't a request to add a new utility type: https://github.com/microsoft/TypeScript/wiki/No-New-Utility-Types
- [x] This feature would agree with the rest of our Design Goals: https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals

### ⭐ Suggestion

Typescript doesn't correctly infer the type when using a symbol as the key when adding a property to a function type.

Here is an example:

```
const TestSymbol: unique symbol = Symbol();

const c = () => {
return 'Hello, world!';
};
c['testProp'] = ['Hello']; // String property is correctly inferred to be of the type string[]
c[TestSymbol] = ['Hello']; // Typescript complains about the type being implicitly any.

c[TestSymbol] = ['Hello'] as string[] // This works as a workaround for this limitation in typescript.
```

The full error from the language server:

```
c[TestSymbol] implicitly has type 'any' because it does not have a type annotation
and is referenced directly or indirectly in its own initializer. (tsserver 7022)
```

Using a symbol this way works without any issues in plain javascript. I've tested Firefox, Chromium, Node and Bun and all these runtimes handle using symbols as property keys on a function without any issue.

It is very limiting not being able to use symbols naturally in typescript the same way they work in javascript. It would be great if typescript could infer the type of the property when using a symbol as the key the same way it does when using a string for the key.

### 📃 Motivating Example

I've not written any blog posts about this.

### 💻 Use Cases

1. What do you want to use this for? I'm building some infrastructure code where I want to append some information to various objects. Using symbols removes the risk of key collisions that can occur when using strings.
3. What shortcomings exist with current approaches? Using strings instead of symbols or manually casting to the expected type can lead to unexpected collisions and type errors.
4. What workarounds are you using in the meantime? Strings and manually casting to the expected type.

Commencez par reproduire l’exemple de propriété de fonction et son diagnostic 7022 de tsserver. Aucun fichier source ni aucun test n’est indiqué ; suivez donc le traitement par le compilateur des propriétés de symbole calculées et des cas d’inférence associés. Le travail est terminé lorsque l’affectation indexée par un symbole infère le type de sa propriété sans annotation explicite, tandis que le comportement existant pour les clés de type chaîne reste inchangé.

Rédigé par le modèle d'indexation à partir du texte de l'issue.