Inference issue: using constants with unique string literal types as record fields

[liam-goodacre-hpe]

TypeScript Version: 2.2.2

Code

const A = 'A' // infers `A : 'A'`
const B = 'B' // infers `B : 'B'`

const n0 = { A, B } // infers `n0 : {A: string, B: string}`
const n1 = { 'A': A, B } // infers `n1 : {'A': string, B: string}`
const n2 = { [A]: A, B } // infers `n2 : {[x: string]: string, B: string}`
const n3 = { [A as 'A']: A, B } // infers `n3 : {[x: string]: string, B: string}`
const n4 = { ['A' as 'A']: A, B } // infers `n4 : {[x: string]: string, B: string}`

Expected behavior:
All n_ should have the same type as n0 - i.e. with a key A.

Actual behavior:
Record type gains an index [x: string]: string.

Background:
I have constants in a namespace that I want to use as field names in a record.

namespace X {
  export const A = 'A'
}
const foo = { [X.A]: 'example' } // infers `foo : { [x: string]: string }`

[cevek]

It's correct behavior because I may update n0.A = 'B' and I don't expect to see an error that type 'A' is not compatible with 'B'

If you want to use literal constants specify it explicitly

const A:'A' = 'A' // infers `A : 'A'`
const B:'B' = 'B' // infers `B : 'B'`

const n0 = { A, B } // n0 type is {A: 'A', B: 'B'}

[liam-goodacre-hpe]

@cevek You've misunderstood: the type of value associated with each field is irrelevant here.
The important bit is which field names are defined on the record, and being able to use constant literals to define what fields exist.

[liam-goodacre-hpe]

Perhaps this is a better demonstration of what I'd like to do playground

[cevek]

@liam-goodacre-hpe I think it links with this issue #5579

[mhegazy]

Should be fixed in latest.