Detect "partial aliased conditions" where string typeof is stored in a const, instead of boolean typeof === expression

[peterflynn]

Suggestion

🔍 Search Terms

aliased conditional expressions, aliased condition, const typeof value, control flow analysis, type narrowing, type guards

✅ 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

TS 4.4 added "Control Flow Analysis of Aliased Conditions", which detects boolean consts that when used in conditionals should narrow the type. The suggestion here is to also detect & narrow the type when other consts (the string value of typeof) are incorporated inside boolean expressions (===) in a conditional.

📃 Motivating Example

(Playground)

// Works - 'arg' is narrowed to type 'string'
function example2_aliasedCheck(arg: unknown) {
    const isString = typeof arg === "string";
    if (isString) {
        console.log(arg.toUpperCase());
    }
}

// ERROR - 'arg' remains type 'unknown'
function example3_aliasedType(arg: unknown) {
    const t = typeof arg;
    if (t === "string") {
        console.log(arg.toUpperCase());  // <-- ERROR
    }
}

Interestingly, it seems like this pattern is already supported for discriminated type unions – in the TS 4.4 release notes above, see the example that reads "Analysis on discriminants in 4.4 also goes a little bit deeper."

This suggestion might potentially apply to other kinds of value-driven type narrowing as well, e.g. truthy checks that act as non-nullable type guards – though that appears to not work yet even with directly inlined checks, so it probably shouldn't be in scope for this suggestion.

💻 Use Cases

The specific example where I saw this was code that 'cached' the typeof result in a const because it had a chain of ifs checking for different type values.

[MartinJohns]

though that appears to not work yet even with directly inlined checks, so it probably shouldn't be in scope for this suggestion.

Narrowing a property does not change the parent type. See #42384 for more information.