Fix typeof switch narrowing

Author: jack-williams

src/compiler/checker.ts

@@ -15261,14 +15261,19 @@ namespace ts {
                   boolean. We know that number cannot be selected
                   because it is caught in the first clause.
                 */
+                const isTypeUnknown = type.flags & TypeFlags.Unknown;
+                const getTypeFromName = (text: string) => text === "function" ? globalFunctionType :
+                    (isTypeUnknown && text === "object") ? getUnionType([nonPrimitiveType, nullType]) :
+                        (typeofTypesByName.get(text) || neverType);
                 if (!(hasDefaultClause || (type.flags & TypeFlags.Union))) {
-                    let impliedType = getTypeWithFacts(getUnionType(clauseWitnesses.map(text => typeofTypesByName.get(text) || neverType)), switchFacts);
+                    let impliedType = getTypeWithFacts(getUnionType(clauseWitnesses.map(getTypeFromName)), switchFacts);
                     if (impliedType.flags & TypeFlags.Union) {
                         impliedType = getAssignmentReducedType(impliedType as UnionType, getBaseConstraintOfType(type) || type);
                     }
                     if (!(impliedType.flags & TypeFlags.Never)) {
                         if (isTypeSubtypeOf(impliedType, type)) {
-                            return impliedType;
+                            // Intersection to handle `string` being a subtype of `keyof T`
+                            return isTypeAny(type) ? impliedType : getIntersectionType([type, impliedType]);
                         }
                         if (type.flags & TypeFlags.Instantiable) {
                             const constraint = getBaseConstraintOfType(type) || anyType;

tests/baselines/reference/narrowingByTypeofInSwitch.js

@@ -27,6 +27,10 @@ function assertObject(x: object) {
     return x;
 }
 
+function assertObjectOrNull(x: object | null) {
+    return x;
+}
+
 function assertUndefined(x: undefined) {
     return x;
 }
@@ -210,6 +214,31 @@ function fallThroughTest(x: string | number | boolean | object) {
             break;
     }
 }
+
+function unknownNarrowing(x: unknown) {
+    switch (typeof x) {
+        case 'number': assertNumber(x); return;
+        case 'boolean': assertBoolean(x); return;
+        case 'function': assertFunction(x); return;
+        case 'symbol': assertSymbol(x); return;
+        case 'object': assertObjectOrNull(x); return;
+        case 'string': assertString(x); return;
+        case 'undefined': assertUndefined(x); return;
+    }
+}
+
+function keyofNarrowing<T>(k: keyof T) {
+    function assertKeyofT(k1: keyof T) { }
+    switch (typeof k) {
+        case 'number': assertNumber(k); assertKeyofT(k); return;
+        case 'symbol': assertSymbol(k); assertKeyofT(k); return;
+        case 'string': assertString(k); assertKeyofT(k); return;
+        case 'boolean': assertNever(k);
+        case 'function': assertNever(k);
+        case 'object': assertNever(k);
+        case 'undefined': assertNever(k); return;
+    }
+}
 
 
 //// [narrowingByTypeofInSwitch.js]
@@ -234,6 +263,9 @@ function assertFunction(x) {
 function assertObject(x) {
     return x;
 }
+function assertObjectOrNull(x) {
+    return x;
+}
 function assertUndefined(x) {
     return x;
 }
@@ -470,3 +502,51 @@ function fallThroughTest(x) {
             break;
     }
 }
+function unknownNarrowing(x) {
+    switch (typeof x) {
+        case 'number':
+            assertNumber(x);
+            return;
+        case 'boolean':
+            assertBoolean(x);
+            return;
+        case 'function':
+            assertFunction(x);
+            return;
+        case 'symbol':
+            assertSymbol(x);
+            return;
+        case 'object':
+            assertObjectOrNull(x);
+            return;
+        case 'string':
+            assertString(x);
+            return;
+        case 'undefined':
+            assertUndefined(x);
+            return;
+    }
+}
+function keyofNarrowing(k) {
+    function assertKeyofT(k1) { }
+    switch (typeof k) {
+        case 'number':
+            assertNumber(k);
+            assertKeyofT(k);
+            return;
+        case 'symbol':
+            assertSymbol(k);
+            assertKeyofT(k);
+            return;
+        case 'string':
+            assertString(k);
+            assertKeyofT(k);
+            return;
+        case 'boolean': assertNever(k);
+        case 'function': assertNever(k);
+        case 'object': assertNever(k);
+        case 'undefined':
+            assertNever(k);
+            return;
+    }
+}