Const indexed access issue — should attempt widening to a mapped type

[smichelForHire]

Bug Report

Anders Hejlsberg (@ahejlsberg) This issue seems nearly identical to #47368, but this time for const object types which are assignable to the mapped type.

🔎 Search Terms

const indexed access; object literal indexed access; object literal widen; widen mapped type

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about indexed access.

⏯ Playground Link

Playground link with relevant code

💻 Code

type ArgMap = { a: number, b: string };
type Func<K extends keyof ArgMap> = (x: ArgMap[K]) => void;
type Funcs = { [K in keyof ArgMap]: Func<K> };

const funcs = {
    a: (x: number) => {},
    b: (x: string) => {},
};

function f1<K extends keyof ArgMap>(key: K, arg: ArgMap[K]) {
    funcs[key](arg);
}

function f2<K extends keyof ArgMap>(key: K, arg: ArgMap[K]) {
    const func = funcs[key];  // Type Funcs[K]
    func(arg);
}

function f3<K extends keyof ArgMap>(key: K, arg: ArgMap[K]) {
    const func: Func<K> = funcs[key];  // Error, Funcs[K] not assignable to Func<K>
    func(arg);
}

🙁 Actual behavior

Unexpected error in example above.

It's unexpected because throwing away type information makes this type check correctly, by widening with either const funcs: Funcs (all examples) or const func: Funcs[K] (in f2). So the compiler actually is able to confirm that indexed type is assignable to the mapped type, it just doesn't try without being explicitly prompted.

🙂 Expected behavior

No errors in example above.

[MartinJohns]

This is working as intended.

K can also be a union type, like "a" | "b". In this case your type Funcs[K] resolves to (x: number) => void | (x: string) => void. When trying to call a union like this, you must provide a value that's compatible with all possible argument types, because the compiler doesn't know whether it has a function accepting a string or a number - so the type you must provide must be both: string & number. But such a type can't be represented, so you end up with never.

f1<"a" | "b">("a", "abc")
f1<"a" | "b">("b", 123)

[RyanCavanaugh]

The error is correct, though if you formulate your arguments to a specific pattern, a convenient soundness hole will be created for you. See #47109

[typescript-bot]

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