Adjust TypeFact calculation for intersections to omit negative typeof facts when an equivalent positive fact is present

src/compiler/checker.ts

@@ -73,7 +73,7 @@ namespace ts {
         TypeofNEString = 1 << 8,      // typeof x !== "string"
         TypeofNENumber = 1 << 9,      // typeof x !== "number"
         TypeofNEBigInt = 1 << 10,     // typeof x !== "bigint"
-        TypeofNEBoolean = 1 << 11,     // typeof x !== "boolean"
+        TypeofNEBoolean = 1 << 11,    // typeof x !== "boolean"
         TypeofNESymbol = 1 << 12,     // typeof x !== "symbol"
         TypeofNEObject = 1 << 13,     // typeof x !== "object"
         TypeofNEFunction = 1 << 14,   // typeof x !== "function"
@@ -90,6 +90,7 @@ namespace ts {
         // The following members encode facts about particular kinds of types for use in the getTypeFacts function.
         // The presence of a particular fact means that the given test is true for some (and possibly all) values
         // of that kind of type.
+        NegativeTypeofFacts = TypeofNEString | TypeofNENumber | TypeofNEBigInt | TypeofNEBoolean | TypeofNESymbol | TypeofNEObject | TypeofNEFunction | TypeofNEHostObject,
         BaseStringStrictFacts = TypeofEQString | TypeofNENumber | TypeofNEBigInt | TypeofNEBoolean | TypeofNESymbol | TypeofNEObject | TypeofNEFunction | TypeofNEHostObject | NEUndefined | NENull | NEUndefinedOrNull,
         BaseStringFacts = BaseStringStrictFacts | EQUndefined | EQNull | EQUndefinedOrNull | Falsy,
         StringStrictFacts = BaseStringStrictFacts | Truthy | Falsy,
@@ -19701,11 +19702,18 @@ namespace ts {
             return declaredType;
         }
 
-        function getTypeFactsOfTypes(types: Type[]): TypeFacts {
+        function getTypeFactsOfTypes(types: Type[], isUnion: boolean): TypeFacts {
             let result: TypeFacts = TypeFacts.None;
             for (const t of types) {
                 result |= getTypeFacts(t);
             }
+            if (!isUnion) {
+                // Get the set of positive facts for the intersection by masking with the negative set shifted left,
+                // then shift those present positive facts into the negative fact value range, and unset any of those
+                // bits (by negating that mask and then intersecting it with the original value)
+                const positiveFacts = result & (TypeFacts.NegativeTypeofFacts >> 8);
+                result &= ~(positiveFacts << 8);
+            }
             return result;
         }
 
@@ -19780,7 +19788,7 @@ namespace ts {
                 return getTypeFacts(getBaseConstraintOfType(type) || unknownType);
             }
             if (flags & TypeFlags.UnionOrIntersection) {
-                return getTypeFactsOfTypes((<UnionOrIntersectionType>type).types);
+                return getTypeFactsOfTypes((<UnionOrIntersectionType>type).types, !!(flags & TypeFlags.Union));
             }
             return TypeFacts.All;
         }

tests/baselines/reference/controlFlowTypeofFunctionElseNarrowing.js

@@ -0,0 +1,26 @@
+//// [controlFlowTypeofFunctionElseNarrowing.ts]
+// regression for https://github.com/microsoft/TypeScript/issues/32928
+// Callable
+type F = (...args: any[]) => any;
+// Callable but intersected
+type F2 = F & { inject?: string[] }
+
+declare const a: string | F2
+
+if (typeof a == 'function') {
+    // only F2
+    a
+} else {
+    // Should be only a string
+    a
+}
+
+//// [controlFlowTypeofFunctionElseNarrowing.js]
+if (typeof a == 'function') {
+    // only F2
+    a;
+}
+else {
+    // Should be only a string
+    a;
+}

tests/baselines/reference/controlFlowTypeofFunctionElseNarrowing.symbols

@@ -0,0 +1,29 @@
+=== tests/cases/conformance/controlFlow/controlFlowTypeofFunctionElseNarrowing.ts ===
+// regression for https://github.com/microsoft/TypeScript/issues/32928
+// Callable
+type F = (...args: any[]) => any;
+>F : Symbol(F, Decl(controlFlowTypeofFunctionElseNarrowing.ts, 0, 0))
+>args : Symbol(args, Decl(controlFlowTypeofFunctionElseNarrowing.ts, 2, 10))
+
+// Callable but intersected
+type F2 = F & { inject?: string[] }
+>F2 : Symbol(F2, Decl(controlFlowTypeofFunctionElseNarrowing.ts, 2, 33))
+>F : Symbol(F, Decl(controlFlowTypeofFunctionElseNarrowing.ts, 0, 0))
+>inject : Symbol(inject, Decl(controlFlowTypeofFunctionElseNarrowing.ts, 4, 15))
+
+declare const a: string | F2
+>a : Symbol(a, Decl(controlFlowTypeofFunctionElseNarrowing.ts, 6, 13))
+>F2 : Symbol(F2, Decl(controlFlowTypeofFunctionElseNarrowing.ts, 2, 33))
+
+if (typeof a == 'function') {
+>a : Symbol(a, Decl(controlFlowTypeofFunctionElseNarrowing.ts, 6, 13))
+
+    // only F2
+    a
+>a : Symbol(a, Decl(controlFlowTypeofFunctionElseNarrowing.ts, 6, 13))
+
+} else {
+    // Should be only a string
+    a
+>a : Symbol(a, Decl(controlFlowTypeofFunctionElseNarrowing.ts, 6, 13))
+}

tests/baselines/reference/controlFlowTypeofFunctionElseNarrowing.types

@@ -0,0 +1,30 @@
+=== tests/cases/conformance/controlFlow/controlFlowTypeofFunctionElseNarrowing.ts ===
+// regression for https://github.com/microsoft/TypeScript/issues/32928
+// Callable
+type F = (...args: any[]) => any;
+>F : F
+>args : any[]
+
+// Callable but intersected
+type F2 = F & { inject?: string[] }
+>F2 : F2
+>inject : string[]
+
+declare const a: string | F2
+>a : string | F2
+
+if (typeof a == 'function') {
+>typeof a == 'function' : boolean
+>typeof a : "string" | "number" | "bigint" | "boolean" | "symbol" | "undefined" | "object" | "function"
+>a : string | F2
+>'function' : "function"
+
+    // only F2
+    a
+>a : F2
+
+} else {
+    // Should be only a string
+    a
+>a : string
+}

tests/cases/conformance/controlFlow/controlFlowTypeofFunctionElseNarrowing.ts

@@ -0,0 +1,15 @@
+// regression for https://github.com/microsoft/TypeScript/issues/32928
+// Callable
+type F = (...args: any[]) => any;
+// Callable but intersected
+type F2 = F & { inject?: string[] }
+
+declare const a: string | F2
+
+if (typeof a == 'function') {
+    // only F2
+    a
+} else {
+    // Should be only a string
+    a
+}