Repository navigation
String index into a generic type having a string index signature isn't assignable to indexed access type #51127
Description
Activity
It seems like maybe over-eager reduction to constraint, i.e. you're getting a concrete
Foo[keyof Foo][string]instead of the genericFoo[K][string]Indexing into a
Foo[K]value with a string key should produce a property of typeFoo[K][string]if such a type is expected from context.There's currently not any effect from contextual typing to whether indexed access produces a deferred or non-deferred type.
It's pretty weird that there's a difference between
stringandnumberindex signatures here, though. Anders Hejlsberg (@ahejlsberg) any thoughts on the motivation here?There's currently not any effect from contextual typing to whether indexed access produces a deferred or non-deferred type.
Really? Maybe I'm not using the term "contextual typing" properly? What accounts for this difference:
interface Foo { a: { [x: number]: string | undefined }; b: { [x: number]: number | undefined }; c: { [x: number]: boolean | undefined }; } function get1<K extends keyof Foo>(foo: Foo, k: K, x: number): Foo[K][number] { const fk: Foo[K] = foo[k]; return fk[x]; } function get2<K extends keyof Foo>(foo: Foo, k: K, x: number) { const fk: Foo[K] = foo[k]; return fk[x]; // string | number | boolean | undefined }
Reacted by M KThat's a widening, the same as you'd see in
mhere:function get2<K extends keyof Foo>(foo: Foo, k: K, x: number) { const fk: Foo[K] = foo[k] let m = fk[x]; }
Reacted by Joe Calzaretta and M KOkay, then I guess I meant "in a non-widening position" instead of "contextually" or something. Unless that's wrong too.
Reacted by M K
Bug Report
🔎 Search Terms
string index signature; indexed access; generic; 2322; not assignable
🕗 Version & Regression Information
This seems to be there all the way back to TS3.5, maybe introduced by #30769, although I'm not sure I understand why.
-This changed between versions 3.3.3 and 3.5.1
⏯ Playground Link
Playground link with relevant code
💻 Code
🙁 Actual behavior
Reading a property with a
stringkey from aFoo[K]object does not produce a value of typeFoo[K][string], even in a non-widening position.🙂 Expected behavior
Indexing into a
Foo[K]value with astringkey should produce a property of typeFoo[K][string]if such a type is in a non-widening position.This might be similar to #31661 and #33181 but I can't tell.
Note that numeric index signatures work as expected:
And known literal keys work as expected:
But string index signatures (and symbol also) fail for some reason.
This can be worked around easily enough:
But I'm wondering what's going on.
Playground link with above examples
(note to self: go back to this SO answer if I acquire more cluefulness here)