Discriminated unions is not work when field key is number

[NWYLZW]

🔎 Search Terms

• discriminated unions, "discriminated-unions"
• "numbers as keys in object", "number key"
• "type guard"

🕗 Version & Regression Information

• This is a crash

⏯ Playground Link

https://www.typescriptlang.org/play?#code/C4TwDgpgBAglC8UB2BXAtgIwgJwNoF0oAfKAZ2GwEskBzAgKHtEigCEEoBvKABgC5k6LNgA0UAIYCAjFAC+xLrwHkqtMZKgByKZrmMAJhADGAG3HZoRgPZJyEgTHqHT5yzbsYBrRpQBmUAApmCCt-cVweQnhorVRMHE0ASi56KDSoa1srEwgAOhMrGgDxRNT0gHpy9Or0gD0AfnpZej9A4NCoDFxNcU0omM044SSU6szSbLyCooxS6sqamoamlv8g8BD-Ls0ePoQBoYTkzjK08cn8woDZ06gFxbrG5tb1yA6uyP3EQaEj0fTzjlLjM5hUqg80stmkA

💻 Code

type A = number[] | string[]

type B = { 0: number, a: 1 } | { 0: string, a: '1' }

declare const a: A
declare const b: B

if (typeof a[0] === 'number') {
    console.log(a)
    //          ^? A
}
if (typeof b['a'] === 'number') {
    console.log(b)
    //          ^? { 0: number, a: 1 }
}
if (typeof b['0'] === 'number') {
    console.log(b)
    //          ^? B
}
if (typeof b[0] === 'number') {
    console.log(b)
    //          ^? B
}

🙁 Actual behavior

Unable to type guard b as an option of the union type B.

🙂 Expected behavior

Type b as { 0: number, a: 1 } when type guarding it with typeof b['0'] === 'number'.

Additional information about the issue

• No type inferrence of callback arguments inside a tuple union type #55632
• Control flow analysis for dependent parameters only works when checking against literals #55766
• Type Prediction for union with typeguard looks different from when we do not use typegurad #55961

[NWYLZW]

It seems that there is no restriction in the documentation that keys must be strings.

[fatcerberus]

It's not about the keys being strings or not - discriminants must be literal-typed. number and string are not valid discriminants, and you also can't do a discriminant check via typeof.

[NWYLZW]

typeof works in some cases, but I completely don't understand it.

[NWYLZW]

?????????????????

[browsnet]

https://www.typescriptlang.org/play?ts=5.4.0-dev.20240131#code/C4TwDgpgBAglC8UDeUBeAuKA7ArgWwCMIAnKAXygB9k1MBnYYgSywHNyoAoUSKAIQQ0M2fEVIVqKYQQD2MgDYQAhlg6cAJhADG8pcWhaZWBlCWYYG7bv1RDx4FAKY+nTkwBmUABQ8IMz0oA2gDkqMEAugjwiMGyCspYwQCUyJxQ6bZGdPEAdPIyrF5KSWkZAPRlGVUZAHoA-Jxkbp4+4H4BIWGR0TG4hCTJqVV22Yp5BUUlVRXV1fWNrh7evv6OnRFRMXGKKoNIpekjufmFBFPllbO1DU1LrZCrBOvd0VDBfWJ7B5nGxxNn3xmV3S8yaQA

It seems that only specific union types trigger this bug. In this example, only the union of number and string triggers the bug, probably because it is inferred as number | string. When I change it to another primitive type union or a literal type, Discriminated works successfully.

[whzx5byb]

boolean is treated as true | false internally, which is literal-typed, and make the property discriminated.

[fatcerberus]

This is the first I'm seeing that typeof works to narrow a discriminated union. That's highly unorthodox (and in this case, even misleading). Maintainers have always said discriminated union narrowing only works with direct value comparisons (i.e. x[0] === 'foo').

[RyanCavanaugh]

Narrowing via type on discriminated unions works by looking for properties that look like discriminant properties... but string[] and number[] don't have any such properties! It could be done, but just isn't right now.

[NWYLZW]

One strange thing here is that if it's not a union type with only string[], there is a partial solution to this problem.

type A = ({ [0]: number } & number[]) | ({ [0]: boolean } & boolean[])

declare const a: A

if (typeof a[0] === 'number') {
    console.log(a)
    //          ^? { [0]: number } & number[]
}
if (typeof a[0] === 'boolean') {
    console.log(a)
    //          ^? { [0]: boolean } & boolean[]

Playground Link

If we replace boolean[] with string[], then a problem will arise.

type A = ({ [0]: number } & number[]) | ({ [0]: string } & string[])

declare const a: A

if (typeof a[0] === 'number') {
    console.log(a)
    //          ^? A
}
if (typeof a[0] === 'string') {
    console.log(a)
    //          ^? A

Playground Link