`keyof` behaves differently with index signatures created using `Record`

[juhort]

Acknowledgement

• I acknowledge that issues using this template may be closed without further explanation at the maintainer's discretion.

Comment

type T1 = { [x: string]: unknown };
//   ^? type T1 = { [x: string]: unknown; }
type K1 = keyof T1;
//   ^? type K1 = string | number


type T2 = Record<string, unknown>;
//   ^? type T2 = { [x: string]: unknown; }
type K2 = keyof T2;
//   ^? type K2 = string

Expected: K2 should have also been string | number because:

1. We can access number from T2:

   type AccessT2 = T2[number]; // ✅ Allowed
   //   ^? type AccessT2 = unknown

2. T2 is the same as T1 so their keyof behavior should also be same.

[MartinJohns]

This is working as intended. Just use these search terms and look through the existing issues: record keyof in:title

[juhort]

@MartinJohns Umm...I went through that actually but couldn't find anything. If you don't mind, can you please link any particular issue?

[MartinJohns]

Did you check the closed issues?

[juhort]

Yeah, I tried checking them.

[MartinJohns]

#45447

[juhort]

#45447 is not the same as this issue.

This issue says both keyof {[x: string]: any} and keyof Record<string, any> should return the same type, and that type should be string | number. But currently the latter returns just string.

@MartinJohns Can you please go through the issue again.

[mkantor]

T2 is the same as T1

This isn't strictly true. While many people use Record as a substitute for index signature syntax, Record is actually a mapped type. It's more like this than your T1:

type T3 = { [_ in string]: unknown };
//   ^? - type T3 = {
//       [x: string]: unknown;
//   }
type K3 = keyof T3;
//   ^? - type K3 = string

At first glance it does seem like mapped types with infinite-sized key domains like this "should" behave identically to their index signature counterparts (implying that K3 ought to be string | number above), but clearly that's not how they are implemented. I have no idea whether this divergence is intentional or not.

In any case I think this issue generalizes to "keyof { [_ in string]: unknown } should be the same as keyof { [_: string]: unknown }".

(By the way, why didn't you use one of the issue templates? Seems like this is either a bug or feature request depending on how you look at it.)

[juhort]

It's more like this than your T1:

That makes sense. In that case, I guess the QuickInfo tooltip shouldn't display the type as an Index Signature.

In any case I think this issue generalizes to "keyof { [_ in string]: unknown } should be the same as keyof { [_: string]: unknown }".

Yup, correct!

[juhort]

(By the way, why didn't you use one of the issue templates? Seems like this is either a bug or feature request depending on how you look at it.)

Yeah, my bad, should have used of the templates.

[mkantor]

the QuickInfo tooltip shouldn't display the type as an Index Signature

+1 to this. Even if this issue is closed as "working as intended" I think the above might deserve its own issue. The current behavior is definitely misleading.

[MartinJohns]

#45447 is not the same as this issue.

This issue says both keyof {[x: string]: any} and keyof Record<string, any> should return the same type, and that type should be string | number. But currently the latter returns just string.

The issue is about the difference of keyof with the indexer type and the Record type (a mapped type). That's the same as your issue.

You likely got confused by the display issue that mkantor showed and believe that the types { [x: string]: unknown } and Record<string, unknown> are the same, but they're not. I believe the display issue fals under: #47214 (comment)

[jcalz]

Duplicate #31013