Revise and simplify CFA for typeof check expressions (microsoft#49422)

* Revise and simplify CFA for `typeof` check expressions

* Accept new baselines

* Add regression test

* Slight change to preserve type when related in both directions

* Add regression test

* Explain reasons for exact sequence of type checks

Author: ahejlsberg

src/compiler/checker.ts

@@ -27,7 +27,7 @@ function boxify<T>(obj: T): Boxified<T> {
 
         for (let k in obj) {
 >k : Extract<keyof T, string>
->obj : (T & null) | (T & object)
+>obj : (T & object) | (T & null)
 
             result[k] = { value: obj[k] };
 >result[k] = { value: obj[k] } : { value: (T & object)[Extract<keyof T, string>]; }

tests/baselines/reference/mappedTypes4.types

@@ -71,6 +71,19 @@ function f100<T, K extends keyof T>(obj: T, keys: K[]) : void {
             item.call(obj);
     }
 }
+
+// Repro from #49316
+
+function configureStore<S extends object>(reducer: (() => void) | Record<keyof S, () => void>) {
+    let rootReducer: () => void;
+    if (typeof reducer === 'function') {
+        rootReducer = reducer;
+    }
+}
+
+function f101(x: string | Record<string, any>) {
+    return typeof x === "object" && x.anything;
+}
 
 
 //// [typeGuardOfFormTypeOfFunction.js]
@@ -137,3 +150,13 @@ function f100(obj, keys) {
             item.call(obj);
     }
 }
+// Repro from #49316
+function configureStore(reducer) {
+    var rootReducer;
+    if (typeof reducer === 'function') {
+        rootReducer = reducer;
+    }
+}
+function f101(x) {
+    return typeof x === "object" && x.anything;
+}

tests/baselines/reference/typeGuardOfFormTypeOfFunction.js

@@ -157,3 +157,34 @@ function f100<T, K extends keyof T>(obj: T, keys: K[]) : void {
     }
 }
 
+// Repro from #49316
+
+function configureStore<S extends object>(reducer: (() => void) | Record<keyof S, () => void>) {
+>configureStore : Symbol(configureStore, Decl(typeGuardOfFormTypeOfFunction.ts, 71, 1))
+>S : Symbol(S, Decl(typeGuardOfFormTypeOfFunction.ts, 75, 24))
+>reducer : Symbol(reducer, Decl(typeGuardOfFormTypeOfFunction.ts, 75, 42))
+>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --))
+>S : Symbol(S, Decl(typeGuardOfFormTypeOfFunction.ts, 75, 24))
+
+    let rootReducer: () => void;
+>rootReducer : Symbol(rootReducer, Decl(typeGuardOfFormTypeOfFunction.ts, 76, 7))
+
+    if (typeof reducer === 'function') {
+>reducer : Symbol(reducer, Decl(typeGuardOfFormTypeOfFunction.ts, 75, 42))
+
+        rootReducer = reducer;
+>rootReducer : Symbol(rootReducer, Decl(typeGuardOfFormTypeOfFunction.ts, 76, 7))
+>reducer : Symbol(reducer, Decl(typeGuardOfFormTypeOfFunction.ts, 75, 42))
+    }
+}
+
+function f101(x: string | Record<string, any>) {
+>f101 : Symbol(f101, Decl(typeGuardOfFormTypeOfFunction.ts, 80, 1))
+>x : Symbol(x, Decl(typeGuardOfFormTypeOfFunction.ts, 82, 14))
+>Record : Symbol(Record, Decl(lib.es5.d.ts, --, --))
+
+    return typeof x === "object" && x.anything;
+>x : Symbol(x, Decl(typeGuardOfFormTypeOfFunction.ts, 82, 14))
+>x : Symbol(x, Decl(typeGuardOfFormTypeOfFunction.ts, 82, 14))
+}
+

tests/baselines/reference/typeGuardOfFormTypeOfFunction.symbols

@@ -182,3 +182,40 @@ function f100<T, K extends keyof T>(obj: T, keys: K[]) : void {
     }
 }
 
+// Repro from #49316
+
+function configureStore<S extends object>(reducer: (() => void) | Record<keyof S, () => void>) {
+>configureStore : <S extends object>(reducer: (() => void) | Record<keyof S, () => void>) => void
+>reducer : Record<keyof S, () => void> | (() => void)
+
+    let rootReducer: () => void;
+>rootReducer : () => void
+
+    if (typeof reducer === 'function') {
+>typeof reducer === 'function' : boolean
+>typeof reducer : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
+>reducer : Record<keyof S, () => void> | (() => void)
+>'function' : "function"
+
+        rootReducer = reducer;
+>rootReducer = reducer : () => void
+>rootReducer : () => void
+>reducer : () => void
+    }
+}
+
+function f101(x: string | Record<string, any>) {
+>f101 : (x: string | Record<string, any>) => any
+>x : string | Record<string, any>
+
+    return typeof x === "object" && x.anything;
+>typeof x === "object" && x.anything : any
+>typeof x === "object" : boolean
+>typeof x : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
+>x : string | Record<string, any>
+>"object" : "object"
+>x.anything : any
+>x : Record<string, any>
+>anything : any
+}
+

tests/baselines/reference/typeGuardOfFormTypeOfFunction.types

@@ -242,7 +242,7 @@ function test9(a: boolean | number) {
     }
     else {
         a;
->a : never
+>a : undefined
     }
 }
 
@@ -259,15 +259,15 @@ function test10(a: boolean | number) {
         if (typeof a === "boolean") {
 >typeof a === "boolean" : boolean
 >typeof a : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
->a : never
+>a : undefined
 >"boolean" : "boolean"
 
             a;
 >a : never
         }
         else {
             a;
->a : never
+>a : undefined
         }
     }
     else {

tests/baselines/reference/typeGuardTypeOfUndefined.types

@@ -410,7 +410,7 @@ function f31<T>(x: T) {
 >"object" : "object"
 
         x;  // T & object | T & null
->x : (T & null) | (T & object)
+>x : (T & object) | (T & null)
     }
     if (x && typeof x === "object") {
 >x && typeof x === "object" : boolean
@@ -424,12 +424,12 @@ function f31<T>(x: T) {
 >x : T & object
     }
     if (typeof x === "object" && x) {
->typeof x === "object" && x : false | (T & null) | (T & object)
+>typeof x === "object" && x : false | (T & object) | (T & null)
 >typeof x === "object" : boolean
 >typeof x : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
 >x : T
 >"object" : "object"
->x : (T & null) | (T & object)
+>x : (T & object) | (T & null)
 
         x;  // T & object
 >x : T & object
@@ -650,9 +650,9 @@ function deepEquals<T>(a: T, b: T): boolean {
 >b : T
 >'object' : "object"
 >!a : boolean
->a : (T & null) | (T & object)
+>a : (T & object) | (T & null)
 >!b : boolean
->b : (T & null) | (T & object)
+>b : (T & object) | (T & null)
 
         return false;
 >false : false

tests/baselines/reference/unknownControlFlow.types

@@ -71,3 +71,16 @@ function f100<T, K extends keyof T>(obj: T, keys: K[]) : void {
             item.call(obj);
     }
 }
+
+// Repro from #49316
+
+function configureStore<S extends object>(reducer: (() => void) | Record<keyof S, () => void>) {
+    let rootReducer: () => void;
+    if (typeof reducer === 'function') {
+        rootReducer = reducer;
+    }
+}
+
+function f101(x: string | Record<string, any>) {
+    return typeof x === "object" && x.anything;
+}