Make inference of index signatures more precise

[aloifolia]

Search Terms

index signature, object, value, field

Suggestion

Currently, it is not possible (or I missing some crucial knowledge here) to infer the concrete type of the value of an object field. So while in the following code the compiler correctly infers bar for a

const a = 'bar'
type b = (typeof a); // this yields "foo"

it fails to do the equivalent in the following example

const t = { foo: 'bar' };
type u = (typeof t)['foo']; // this yields string

The compiler should literal types for values in objects, as well.

Use Cases

I would like to be able to infer the types of configuration objects without having to explicitly annotate them. This would allow me to write such objects without much hassle and simultaneously use Typescripts inference mechanism to reason about the well-definedness of these values.

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, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

[jack-williams]

Essentially a duplicate of #10195 I think.

[aloifolia]

@jack-williams Yes, I guess this is a specific case of the more general inference problem mentioned in #10195. I summarized my findings there, as well.

[typescript-bot]

This issue has been marked as a 'Duplicate' and has seen no recent activity. It has been automatically closed for house-keeping purposes.