keyof has different literal type behavior when used in function signature

[asmundg]

Apologies in advance for any imprecise use of terminology. Hopefully, the example code demonstrates what I'm trying to say. :)

TypeScript Version: 2.7.0-dev.20171209

Code

interface Foo {
    a: number
    b: number
}

// No error
const k: keyof Foo = "a"
const u: { a: number } | { b: number } = { [k]: 1 }

function foo(k2: keyof Foo): void {
    /**
     * error TS2322: Type '{ [x: string]: number; }' is not assignable to type '{ a: number; } | { b: number; }'.
     *   Type '{ [x: string]: number; }' is not assignable to type '{ b: number; }'.
     *     Property 'b' is missing in type '{ [x: string]: number; }'.
     */
    const u: { a: number } | { b: number } = { [k2]: 1 }
}

Expected behavior:

It seems like keyof should produce the same literal type in both cases and never widen the type when used as the key in an object literal.

Actual behavior:

In practice, keyof produces the expected literal type when used in a const declaration, but produces a type that widens to string when used in a function signature.

[DanielRosenwasser]

The compiler is being a bit too smart by ignoring the type annotation on k and assuming its type is "a", which is probably a bug.

Because the compiler was "wrong" in the above point, it gives you the behavior you want; however, if we fixed it, you'd get the same behavior as within the function.

[asmundg]

You're right, I missed that k, according to tsserver, appears to change type between its declaration and use.

I take it that the reason the "wrong" indexer is inferred, is related to the lack of support for string literal unions as indexer key types?

[ahejlsberg]

This is working as intended. The declared type of k is "a" | "b" (i.e. keyof Foo), but it is narrowed by flow control analysis to "a" based on the initial value assigned to k. Therefore we know that { [k]: 1 } creates an object of type { a: number }. However, in the case of k2 we only know the declared type "a" | "b" and { [k2]: 1 } is given type { [x: string]: number } (because k2 doesn't have a unit type).

You could argue that for { [k2]: 1 } we should produce a value of type { a: number } | { b: number } by distributing the literal union type "a" | "b" over the object literal. We don't do that and it probably isn't feasible to do so. For example, if the object literal had multiple properties declared this way we'd end up with a combinatorial explosion of types in the union.

[typescript-bot]

Automatically closing this issue for housekeeping purposes. The issue labels indicate that it is unactionable at the moment or has already been addressed.