Misleading error message "'{}' and 'number' have no overlap"

[kirkwaiblinger]

🔎 Search Terms

empty object type, unintentional comparison

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about object types and structural typing

⏯ Playground Link

https://www.typescriptlang.org/play/?noUncheckedIndexedAccess=true&target=99&ts=5.8.0-dev.20241124#code/JYMwBAFA3gvmC8iwAYCUZZA

💻 Code

if ({} === 0) {}

🙁 Actual behavior

TS 2367: "This comparison appears to be unintentional because the types '{}' and 'number' have no overlap."

🙂 Expected behavior

TS 2367: "This comparison appears to be unintentional because the types 'object' and 'number' have no overlap."

Additional information about the issue

the type {} and number do have overlap; number is a subset of {}.

declare const n: number;
// allowed!
const emptyObjectType: {} = n;

TS is correct to report an error, but it should give a technically correct reason for the error.

Analogous (very contrived) examples can be made for similar coincidentally-including-primitive types, like

// This comparison appears to be unintentional because the types '{ toFixed(): string; toPrecision(): string; }' and 'number' have no overlap.
if ({ toFixed(): string { return "" }; toPrecision(): string { return "" }} === 0) {}

// yet this is allowed
const numbery: { toFixed(): string; toPrecision(): string; } = 0;

Stems from discord discussion beginning here: https://discord.com/channels/508357248330760243/508357638677856287/1310419206260654081

Closely related to discussion regarding #60582

[RyanCavanaugh]

Error messages are supposed to clue you into what's wrong, not be a language spec, and "doesn't overlap" is the easiest way to understand why we're flagging this error.

Open to suggestions on a better phrasing that is easier to understand in the general case, though.

[kirkwaiblinger]

TBH, I haven't been able to get the error to trigger without providing an object literal in the comparison. That is to say,

// has TS errors.
// This comparison appears to be unintentional because the types '{}' and 'number' have no overlap.(2367)
// This condition will always return 'false' since JavaScript compares objects by reference, not value.(2839)
if ({} === 0) {
}

// no errors.
declare const oDeclared: {};
if (oDeclared === 0) {
}

// also no erorrs
const oLiteral = {};
if (oLiteral === 0) {
}

TS 2839 seems to be the more accurate and unambiguous error here. TS 2367 apparently doesn't generalize, since it doesn't get triggered when a literal isn't provided... which means that the only times it's triggered it's redundant with TS 2839 anyway. At least as far as I've been able to tell from experimentation.

If the above is a correct observation, my suggestion is - why not just remove TS 2367 from this case entirely, and just leave TS 2839?