Narrow like we're executing

Author: jakebailey

src/compiler/checker.ts

@@ -28040,26 +28040,31 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
         }
 
         function narrowTypeBySwitchOnTrue(type: Type, switchStatement: SwitchStatement, clauseStart: number, clauseEnd: number): Type {
-            const clauses = switchStatement.caseBlock.clauses.slice(clauseStart, clauseEnd);
-            const clausesType = narrowTypeForTrueClauses(type, clauses);
             const defaultIndex = findIndex(switchStatement.caseBlock.clauses, clause => clause.kind === SyntaxKind.DefaultClause);
             const hasDefaultClause = clauseStart === clauseEnd || (defaultIndex >= clauseStart && defaultIndex < clauseEnd);
-            if (hasDefaultClause) {
-                // If we have a default in this set of clauses, then the type could also be any of the types
-                // that aren't covered by the other cases.
-
-                const clausesBefore = switchStatement.caseBlock.clauses.slice(0, clauseStart);
-                const clausesAfter = switchStatement.caseBlock.clauses.slice(clauseEnd);
 
-                const before = narrowTypeForTrueClauses(type, clausesBefore);
-                const after = narrowTypeForTrueClauses(type, clausesAfter);
-                const other = getUnionType([before, after]);
-
-                const typeNotOther = filterType(type, t => !isTypeSubsetOf(t, other));
+            // First, narrow away all of the cases that preceded this set of cases.
+            const clausesBefore = switchStatement.caseBlock.clauses.slice(0, clauseStart);
+            for (const clause of clausesBefore) {
+                if (clause.kind === SyntaxKind.CaseClause) {
+                    type = narrowType(type, clause.expression, /*assumeTrue*/ false);
+                }
+            }
 
-                return getUnionType([clausesType, typeNotOther]);
+            // If our current set has a default, then none the other cases were hit either.
+            if (hasDefaultClause) {
+                const clausesAfter = switchStatement.caseBlock.clauses.slice(clauseEnd);
+                for (const clause of clausesAfter) {
+                    if (clause.kind === SyntaxKind.CaseClause) {
+                        type = narrowType(type, clause.expression, /*assumeTrue*/ false);
+                    }
+                }
+                return type;
             }
-            return clausesType;
+
+            // Now, add back what we learned using the current set of cases.
+            const clauses = switchStatement.caseBlock.clauses.slice(clauseStart, clauseEnd);
+            return narrowTypeForTrueClauses(type, clauses);
         }
 
         function narrowTypeForTrueClauses(type: Type, clauses: CaseOrDefaultClause[]) {

tests/baselines/reference/narrowByClauseExpressionInSwitchTrue3.errors.txt

@@ -1,7 +1,9 @@
+narrowByClauseExpressionInSwitchTrue3.ts(12,9): error TS2367: This comparison appears to be unintentional because the types '"square"' and '"circle"' have no overlap.
+narrowByClauseExpressionInSwitchTrue3.ts(13,32): error TS2339: Property 'radius' does not exist on type 'never'.
 narrowByClauseExpressionInSwitchTrue3.ts(15,14): error TS2367: This comparison appears to be unintentional because the types '"square"' and '"circle"' have no overlap.
 
 
-==== narrowByClauseExpressionInSwitchTrue3.ts (1 errors) ====
+==== narrowByClauseExpressionInSwitchTrue3.ts (3 errors) ====
     type Shape =
         | { kind: "circle", radius: number }
         | { kind: "square", sideLength: number }
@@ -14,7 +16,11 @@ narrowByClauseExpressionInSwitchTrue3.ts(15,14): error TS2367: This comparison a
         }
 
         if (shape.kind === "circle") {
+            ~~~~~~~~~~~~~~~~~~~~~~~
+!!! error TS2367: This comparison appears to be unintentional because the types '"square"' and '"circle"' have no overlap.
             return Math.PI * shape.radius ** 2;
+                                   ~~~~~~
+!!! error TS2339: Property 'radius' does not exist on type 'never'.
         }
         else if (shape.kind === "circle") {
                  ~~~~~~~~~~~~~~~~~~~~~~~

tests/baselines/reference/narrowByClauseExpressionInSwitchTrue3.symbols

@@ -38,17 +38,15 @@ function wat(shape: Shape) {
     }
 
     if (shape.kind === "circle") {
->shape.kind : Symbol(kind, Decl(narrowByClauseExpressionInSwitchTrue3.ts, 1, 7), Decl(narrowByClauseExpressionInSwitchTrue3.ts, 2, 7))
+>shape.kind : Symbol(kind, Decl(narrowByClauseExpressionInSwitchTrue3.ts, 2, 7))
 >shape : Symbol(shape, Decl(narrowByClauseExpressionInSwitchTrue3.ts, 4, 13))
->kind : Symbol(kind, Decl(narrowByClauseExpressionInSwitchTrue3.ts, 1, 7), Decl(narrowByClauseExpressionInSwitchTrue3.ts, 2, 7))
+>kind : Symbol(kind, Decl(narrowByClauseExpressionInSwitchTrue3.ts, 2, 7))
 
         return Math.PI * shape.radius ** 2;
 >Math.PI : Symbol(Math.PI, Decl(lib.es5.d.ts, --, --))
 >Math : Symbol(Math, Decl(lib.es5.d.ts, --, --), Decl(lib.es5.d.ts, --, --))
 >PI : Symbol(Math.PI, Decl(lib.es5.d.ts, --, --))
->shape.radius : Symbol(radius, Decl(narrowByClauseExpressionInSwitchTrue3.ts, 1, 23))
 >shape : Symbol(shape, Decl(narrowByClauseExpressionInSwitchTrue3.ts, 4, 13))
->radius : Symbol(radius, Decl(narrowByClauseExpressionInSwitchTrue3.ts, 1, 23))
     }
     else if (shape.kind === "circle") {
 >shape.kind : Symbol(kind, Decl(narrowByClauseExpressionInSwitchTrue3.ts, 2, 7))

tests/baselines/reference/narrowByClauseExpressionInSwitchTrue3.types

@@ -47,9 +47,9 @@ function wat(shape: Shape) {
 
     if (shape.kind === "circle") {
 >shape.kind === "circle" : boolean
->shape.kind : "circle" | "square"
->shape : Shape
->kind : "circle" | "square"
+>shape.kind : "square"
+>shape : { kind: "square"; sideLength: number; }
+>kind : "square"
 >"circle" : "circle"
 
         return Math.PI * shape.radius ** 2;
@@ -58,9 +58,9 @@ function wat(shape: Shape) {
 >Math : Math
 >PI : number
 >shape.radius ** 2 : number
->shape.radius : number
->shape : { kind: "circle"; radius: number; }
->radius : number
+>shape.radius : any
+>shape : never
+>radius : any
 >2 : 2
     }
     else if (shape.kind === "circle") {

tests/baselines/reference/narrowByClauseExpressionInSwitchTrue6.types

@@ -139,9 +139,9 @@ function isA(x: MyType) {
 
         default:
             x.aProps;
->x.aProps : never
+>x.aProps : string
 >x : A
->aProps : never
+>aProps : string
 
             break;
         case x.kind === "b":

tests/baselines/reference/narrowByClauseExpressionInSwitchTrue8.types

@@ -26,7 +26,7 @@ function foo(cond1: boolean, cond2: boolean) {
 >cond2 : boolean
 
             cond1; // Should be false?
->cond1 : boolean
+>cond1 : false
 
             //  ^?
             cond2; // Should be true
@@ -37,11 +37,11 @@ function foo(cond1: boolean, cond2: boolean) {
 
         default:
             cond1; // Should be false?
->cond1 : never
+>cond1 : false
 
             //  ^?
             cond2; // Should be false?
->cond2 : never
+>cond2 : false
 
             //  ^?
             break;

tests/baselines/reference/narrowByClauseExpressionInSwitchTrue9.errors.txt

@@ -31,6 +31,9 @@ class Foo {
             default:
                 let x = this.mine;
 >x : Symbol(x, Decl(narrowByClauseExpressionInSwitchTrue9.ts, 13, 19))
+>this.mine : Symbol(Foo.mine, Decl(narrowByClauseExpressionInSwitchTrue9.ts, 4, 11))
+>this : Symbol(Foo, Decl(narrowByClauseExpressionInSwitchTrue9.ts, 2, 1))
+>mine : Symbol(Foo.mine, Decl(narrowByClauseExpressionInSwitchTrue9.ts, 4, 11))
         }
     }
 }

tests/baselines/reference/narrowByClauseExpressionInSwitchTrue9.symbols

@@ -30,10 +30,10 @@ class Foo {
                 break;
             default:
                 let x = this.mine;
->x : any
->this.mine : any
->this : never
->mine : any
+>x : string
+>this.mine : string
+>this : this
+>mine : string
         }
     }
 }