Use a different method to calculate default case

Author: jakebailey

src/compiler/checker.ts

@@ -28041,20 +28041,32 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
             const defaultIndex = findIndex(switchStatement.caseBlock.clauses, clause => clause.kind === SyntaxKind.DefaultClause);
             const hasDefaultClause = clauseStart === clauseEnd || (defaultIndex >= clauseStart && defaultIndex < clauseEnd);
             if (hasDefaultClause) {
-                // 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.
+                // If we have a default in this set of clauses, then we want to say that any of the other
+                // clauses in this set are true, but also that any of the other clauses not in this set
+                // may be false.
+                // TODO(jakebailey): this needs to be better explained and cleaned up.
+
                 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]);
+
+                const before = narrowTypeForTrueClauses(type, clausesBefore);
+                const after = narrowTypeForTrueClauses(type, clausesAfter);
+                const other = getUnionType([before, after]);
+                const clausesType = narrowTypeForTrueClauses(type, clauses);
+
+                // TODO(jakebailey): should this be something other than areTypesComparable?
+                // It feels like this should be doing some sort of subtyping, but other narrowings
+                // like this use areTypesComparable...
+                const typeNotOther = filterType(type, t => !areTypesComparable(t, other));
+
+                return getUnionType([clausesType, typeNotOther]);
             }
             // In the non-default cause we create a union of the type narrowed by each of the listed cases.
-            return narrowTypeForClauses(type, clauses, /*assumeTrue*/ true);
+            return narrowTypeForTrueClauses(type, clauses);
         }
 
-        function narrowTypeForClauses(type: Type, clauses: CaseOrDefaultClause[], assumeTrue: boolean) {
-            return getUnionType(map(clauses, clause => clause.kind === SyntaxKind.CaseClause ? narrowType(type, clause.expression, assumeTrue) : neverType));
+        function narrowTypeForTrueClauses(type: Type, clauses: CaseOrDefaultClause[]) {
+            return getUnionType(map(clauses, clause => clause.kind === SyntaxKind.CaseClause ? narrowType(type, clause.expression, /*assumeTrue*/ true) : neverType));
         }
 
         function isMatchingConstructorReference(expr: Expression) {

tests/baselines/reference/narrowByClauseExpressionInSwitchTrue2.types

@@ -25,7 +25,7 @@ switch(true) {
         break
     default:
         f;
->f : "a" | "b" | "c"
+>f : "c"
 }
 
 f;
@@ -53,7 +53,7 @@ switch(true) {
         break
     default:
         f;
->f : "a" | "b" | "c"
+>f : "c"
 }
 
 f;

tests/baselines/reference/narrowByClauseExpressionInSwitchTrue3.errors.txt

@@ -65,9 +65,9 @@ function wat(shape: Shape) {
     }
     else if (shape.kind === "circle") {
 >shape.kind === "circle" : boolean
->shape.kind : "square"
+>shape.kind : never
 >shape : { kind: "square"; sideLength: number; }
->kind : "square"
+>kind : never
 >"circle" : "circle"
 
         //         ~~~~

tests/baselines/reference/narrowByClauseExpressionInSwitchTrue3.types

@@ -81,13 +81,13 @@ function fn1switch(input: All) {
             break;
         default:
             input; // Should be D | E
->input : A | B | C | D | E
+>input : D | E
 
             //  ^?
     }
 
     input; // Should not be A
->input : All
+>input : B | C | D | E
 
     //  ^?
 }
@@ -206,7 +206,7 @@ function fn2switch(input: All) {
             break;
         default:
             input; // Should be D | E
->input : A | B | C | D | E
+>input : D | E
 
             //  ^?
             return;
@@ -321,7 +321,7 @@ function fn3switch(input: All) {
             // fallthrough
         default:
             input; // Should be B | D | E
->input : All
+>input : B | D | E
 
             //  ^?
             break;
@@ -341,7 +341,7 @@ function fn3switch(input: All) {
     }
 
     input; // Should not be A
->input : All
+>input : B | C | D | E
 
     //  ^?
 }