Output from JavaScript operator typeof should be type-checked as a string

[patik]

Suggestion

🔍 Search Terms

List of keywords you searched for before creating this issue: typeof

✅ Viability Checklist

My suggestion meets these guidelines:

• This wouldn't be a breaking change in existing TypeScript/JavaScript code
• This wouldn't change the runtime behavior of existing JavaScript code
• This could be implemented without emitting different JS based on the types of the expressions
• This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, new syntax sugar for JS, etc.)
• This feature would agree with the rest of TypeScript's Design Goals.

⭐ Suggestion

The traditional typeof operator (not the TS one!) returns a string, but TypeScript does not always type-check it as such:

// The compiler throws two exceptions for this:
// This comparison appears to be unintentional because the types 'string' and 'never[]' have no overlap.(2367)
// This condition will always return 'false' since JavaScript compares objects by reference, not value.(2839)
if (typeof foo === []) {
    //
}

// But the compiler does allow this, even though the lefthand side is a string and the righthand side is `undefined`
if (typeof foo === undefined) {
    // 
}

Playground

When strict equality is used, I would expect the compiler to also throw 2367 and 2839 when This seems to be the case for undefined, null, and {}.

📃 Motivating Example

This code is allowed, but I think TS should have caught it:

if (typeof window === undefined) {
    //
}

💻 Use Cases

The output of typeof is often compared to other variables, and TS should make sure those variables are also strings, at least when using ===.

[Josh-Cena]

Duplicate of #29200

[fatcerberus]

Also note this is not specific to typeof. typeof foo is in fact already typed as string; comparison of anything with undefined is just always allowed.

[Andarist]

It would be fairly easy to improve this situation for noUncheckedIndexedAccess but I have no idea how to improve this outside of this setting. The problem is that this code has to work:

function parse(config: Record<string, number>) {
  if (config.a === undefined) {
  }
}

And we have no way of knowing if the left type in this comparison comes from the index signature or not. The check responsible for allowing those comparisons can be found in isTypeEqualityComparableTo

[typescript-bot]

This issue has been marked as "Duplicate" and has seen no recent activity. It has been automatically closed for house-keeping purposes.