Attempt to fix things

jakebailey · jakebailey · commit a98c233f999b · 2023-10-05T10:24:11.000-07:00
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
@@ -28037,17 +28037,24 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         }
 
         function narrowTypeBySwitchOnTrue(type: Type, switchStatement: SwitchStatement, clauseStart: number, clauseEnd: number): Type {
-            // Equal start and end denotes implicit fallthrough; undefined marks explicit default clause.
+            const clauses = switchStatement.caseBlock.clauses.slice(clauseStart, clauseEnd);
             const defaultIndex = findIndex(switchStatement.caseBlock.clauses, clause => clause.kind === SyntaxKind.DefaultClause);
             const hasDefaultClause = clauseStart === clauseEnd || (defaultIndex >= clauseStart && defaultIndex < clauseEnd);
             if (hasDefaultClause) {
-                // Here we'd need to find the opposite of all of the other cases, but without control flow,
-                // the best we can do is to not narrow at all.
-                return type;
+                // In the default case, we need to assume that all of the other cases were false,
+                // but also that any of the other cases in this block are true.
+                const clausesBefore = switchStatement.caseBlock.clauses.slice(0, clauseStart);
+                const before = narrowTypeForClauses(type, clausesBefore, /*assumeTrue*/ false);
+                const clausesAfter = switchStatement.caseBlock.clauses.slice(clauseEnd);
+                const after = narrowTypeForClauses(type, clausesAfter, /*assumeTrue*/ false);
+                return getUnionType([narrowTypeForClauses(type, clauses, /*assumeTrue*/ true), before, after]);
             }
             // In the non-default cause we create a union of the type narrowed by each of the listed cases.
-            const clauses = switchStatement.caseBlock.clauses.slice(clauseStart, clauseEnd);
-            return getUnionType(map(clauses, clause => clause && clause.kind === SyntaxKind.CaseClause ? narrowType(type, clause.expression, /*assumeTrue*/ true) : neverType));
+            return narrowTypeForClauses(type, clauses, /*assumeTrue*/ true);
+        }
+
+        function narrowTypeForClauses(type: Type, clauses: CaseOrDefaultClause[], assumeTrue: boolean) {
+            return getUnionType(map(clauses, clause => clause.kind === SyntaxKind.CaseClause ? narrowType(type, clause.expression, assumeTrue) : neverType));
         }
 
         function isMatchingConstructorReference(expr: Expression) {
diff --git a/tests/baselines/reference/narrowByClauseExpressionInSwitchTrue4.types b/tests/baselines/reference/narrowByClauseExpressionInSwitchTrue4.types
@@ -14,7 +14,7 @@ switch (true) {
 
   default:
     f;
->f : "a" | "b" | "c"
+>f : "a" | "c"
 
   case f === "b":
 >f === "b" : boolean
