fix(50340): typeof ... === "undefined" check on discriminated union of undefined and object type doesn't narrow correctly

src/compiler/checker.ts

@@ -25260,11 +25260,19 @@ namespace ts {
                 }
                 const target = getReferenceCandidate(typeOfExpr.expression);
                 if (!isMatchingReference(reference, target)) {
+                    const propertyAccess = getDiscriminantPropertyAccess(typeOfExpr.expression, type);
+                    if (propertyAccess) {
+                        return narrowTypeByDiscriminant(type, propertyAccess, t => narrowTypeByLiteralExpression(t, literal, assumeTrue));
+                    }
                     if (strictNullChecks && optionalChainContainsReference(target, reference) && assumeTrue === (literal.text !== "undefined")) {
                         return getAdjustedTypeWithFacts(type, TypeFacts.NEUndefinedOrNull);
                     }
                     return type;
                 }
+                return narrowTypeByLiteralExpression(type, literal, assumeTrue);
+            }
+
+            function narrowTypeByLiteralExpression(type: Type, literal: LiteralExpression, assumeTrue: boolean) {
                 return assumeTrue ?
                     narrowTypeByTypeName(type, literal.text) :
                     getTypeWithFacts(type, typeofNEFacts.get(literal.text) || TypeFacts.TypeofNEHostObject);

tests/baselines/reference/narrowingTypeofUndefined.js

@@ -0,0 +1,12 @@
+//// [narrowingTypeofUndefined.ts]
+declare const a: { error: { a: string }, result: undefined } | { error: undefined, result: { b: number } }
+
+if (typeof a.error === 'undefined') {
+    a.result.b; // ok
+}
+
+
+//// [narrowingTypeofUndefined.js]
+if (typeof a.error === 'undefined') {
+    a.result.b; // ok
+}

tests/baselines/reference/narrowingTypeofUndefined.symbols

@@ -0,0 +1,23 @@
+=== tests/cases/compiler/narrowingTypeofUndefined.ts ===
+declare const a: { error: { a: string }, result: undefined } | { error: undefined, result: { b: number } }
+>a : Symbol(a, Decl(narrowingTypeofUndefined.ts, 0, 13))
+>error : Symbol(error, Decl(narrowingTypeofUndefined.ts, 0, 18))
+>a : Symbol(a, Decl(narrowingTypeofUndefined.ts, 0, 27))
+>result : Symbol(result, Decl(narrowingTypeofUndefined.ts, 0, 40))
+>error : Symbol(error, Decl(narrowingTypeofUndefined.ts, 0, 64))
+>result : Symbol(result, Decl(narrowingTypeofUndefined.ts, 0, 82))
+>b : Symbol(b, Decl(narrowingTypeofUndefined.ts, 0, 92))
+
+if (typeof a.error === 'undefined') {
+>a.error : Symbol(error, Decl(narrowingTypeofUndefined.ts, 0, 18), Decl(narrowingTypeofUndefined.ts, 0, 64))
+>a : Symbol(a, Decl(narrowingTypeofUndefined.ts, 0, 13))
+>error : Symbol(error, Decl(narrowingTypeofUndefined.ts, 0, 18), Decl(narrowingTypeofUndefined.ts, 0, 64))
+
+    a.result.b; // ok
+>a.result.b : Symbol(b, Decl(narrowingTypeofUndefined.ts, 0, 92))
+>a.result : Symbol(result, Decl(narrowingTypeofUndefined.ts, 0, 40), Decl(narrowingTypeofUndefined.ts, 0, 82))
+>a : Symbol(a, Decl(narrowingTypeofUndefined.ts, 0, 13))
+>result : Symbol(result, Decl(narrowingTypeofUndefined.ts, 0, 40), Decl(narrowingTypeofUndefined.ts, 0, 82))
+>b : Symbol(b, Decl(narrowingTypeofUndefined.ts, 0, 92))
+}
+

tests/baselines/reference/narrowingTypeofUndefined.types

@@ -0,0 +1,26 @@
+=== tests/cases/compiler/narrowingTypeofUndefined.ts ===
+declare const a: { error: { a: string }, result: undefined } | { error: undefined, result: { b: number } }
+>a : { error: {    a: string;}; result: undefined; } | { error: undefined; result: {    b: number;}; }
+>error : { a: string; }
+>a : string
+>result : undefined
+>error : undefined
+>result : { b: number; }
+>b : number
+
+if (typeof a.error === 'undefined') {
+>typeof a.error === 'undefined' : boolean
+>typeof a.error : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
+>a.error : { a: string; }
+>a : { error: { a: string; }; result: undefined; } | { error: undefined; result: { b: number; }; }
+>error : { a: string; }
+>'undefined' : "undefined"
+
+    a.result.b; // ok
+>a.result.b : number
+>a.result : { b: number; }
+>a : { error: { a: string; }; result: undefined; } | { error: undefined; result: { b: number; }; }
+>result : { b: number; }
+>b : number
+}
+

tests/cases/compiler/narrowingTypeofUndefined.ts

@@ -0,0 +1,5 @@
+declare const a: { error: { a: string }, result: undefined } | { error: undefined, result: { b: number } }
+
+if (typeof a.error === 'undefined') {
+    a.result.b; // ok
+}