Typescript fail to pick up error with Nullish Coalescing Operator

[brenhub24]

🔎 Search Terms

Nullish Coalescing Operator
Type check

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about Common "Bugs" That Aren't Bugs___

⏯ Playground Link

https://www.typescriptlang.org/play/?ts=6.0.0-dev.20251207#code/C4TwDgpgBAKghgcygXigIgIJqgH3QIWzzQGE0AoUSKAZQHsBbCYACwEsA7JVAb3KgFRgiAM4YATuLggA-AC5YiANoBdcgF9K4aPSatOCAKIAbEdF79BwhCICycMAp5KA1lE6KEK+UPEBXCE1NADM-DgBjYDY6DigGBwAKTjA-YCgFXWZ2LlUASnTaRiyDEzNVKD5BKHFmP3FY5NSAOniwBISRIv0uXOQAPgTKqqtRe0coTr1shCbrMUlpKBkZCs0q9VzcgG4NcnJwmJE0xrSMrunylCglSwEeOYkpEAUlTDQAGgIP9DIVdXfbqtyGp9oc6MYIE1jHQEAkAFI0ADyADkmkdxAY2MEQAlWkkOClgJtcnsgA

💻 Code

type Tag = "A" | "B" | "C"
type Something = {
    tagsArray?: Tag[]
}
type SomethingElse = {
    tagsMap: {[k in Tag]?: true}
}
function map(input : Something[]) : SomethingElse[] {
    return input.map((something)=>({
        tagsMap: something.tagsArray ?? {}
    }));
}

const input : Something[]  = [
    {tagsArray: ["A", "B", "C"]},
    {}
]

console.log(JSON.stringify(map(input)))

🙁 Actual behavior

Typescript happily passed this line
tagsMap: something.tagsArray ?? {}
This allows potentially assigning an array to type {[k in Tag]?: true}
Looks like the Nullish Coalescing Operator confused typescript?

🙂 Expected behavior

Typescript should report an error there

Additional information about the issue

Tested in both 5.9.3 and v6.0.0-dev.20251207

[jcalz]

This has little do do with nullish coalescing per se. You can see effectively the same issue this way:

const foo = Math.random() < 0.5 ? ["abc"] : {};
const bar: { a?: string } = foo; // no compiler error

Here foo is inferred to be of type {}; the union of type string[] of the array literal ["abc"] and the type {} of the empty object literal {} becomes {}. I guess the normalization of missing properties, from #19513, doesn't happen for array literals. This union is the same thing that happens with nullish coalescing.

Then foo is accepted as a value of type {a?: string}. An empty object type is always accepted as assignable to a weak object type, even though there are no overlapping properties (so weak type detection, from #16047, doesn't catch this). So you end up with an array where a Partial object type is expected.

All of the above is intentional TypeScript behavior but it's confusing.

[RyanCavanaugh]

This is admittedly annoying, but I don't see a way to fix it without making something else substantially worse