Generic template literal index does not resolve value type

[zachkirsch]

Bug Report

🔎 Search Terms

template string key generic "is not assignable to type"

🕗 Version & Regression Information

• This changed between versions 4.6.4 and 4.7.4

⏯ Playground Link

Playground link with relevant code

💻 Code

// ObjectWithUnderscoredKeys creates an object where:
//   Keys are the strings in K, except each with an underscore prefix
//   Values are all `true`
export type ObjectWithUnderscoredKeys<K extends string> = {
    [k in K as `_${k}`]: true;
};

// it works without generics
function nonGenericTest(objectWithUnderscoredKeys: ObjectWithUnderscoredKeys<"foo" | "bar">, key: "foo" | "bar") {
  const shouldBeTrue: true = objectWithUnderscoredKeys[`_${key}`];
}

// but not with generics
function genericTest<K extends string>(objectWithUnderscoredKeys: ObjectWithUnderscoredKeys<K>, key: K) {
  // ERROR:
  // Type 'ObjectWithUnderscoredKeys<K>[`_${K}`]' is not assignable to type 'true'.
  //   Type 'ObjectWithUnderscoredKeys<K>[`_${string}`]' is not assignable to type 'true'.
  const shouldBeTrue: true = objectWithUnderscoredKeys[`_${key}`];
}

🙁 Actual behavior

In the generic function genericTest, indexing into the object doesn't yield a value with the type true.

🙂 Expected behavior

In the generic function genericTest, indexing into the object should yield a value with the type true.

Related issues

This seems similar to #48983, but that was marked as Working as intended and the behavior in this example doesn't seem like it should be intended.

[zachkirsch]

Thanks @weswigham !!

[Andarist]

@zachkirsch FYI, the "fix" for this will get reverted: #57202

[ahejlsberg]

It's not clear to me this is an issue we want to fix. In the issue example, every property is of type true and we could consider recognizing that regardless of the key type. But that's not really a particularly common scenario, and anyway is better handled by just writing Record<`_${K}`, true>.

In mapped types where the template type actually depends on the iteration type, such as

type Foo<T extends string> = {
    [K in T as `_${K}`]: K;
}

to understand the constraint of Foo[X] for some generic type X we would need to create a reverse mapping that somehow strips the leading underscore from X. That's non-trivial and would work only because the as clause type is perfectly reversible in this example. Quite often as clause types aren't, and then there's nothing we can do. I'm not convinced it is worth the effort do attempt any of this.