Control flow based type guards

src/compiler/parser.ts

@@ -1811,7 +1811,7 @@ namespace ts {
         function parseEntityName(allowReservedWords: boolean, diagnosticMessage?: DiagnosticMessage): EntityName {
             let entity: EntityName = parseIdentifier(diagnosticMessage);
             while (parseOptional(SyntaxKind.DotToken)) {
-                const node = <QualifiedName>createNode(SyntaxKind.QualifiedName, entity.pos);
+                const node: QualifiedName = <QualifiedName>createNode(SyntaxKind.QualifiedName, entity.pos);
                 node.left = entity;
                 node.right = parseRightSideOfDot(allowReservedWords);
                 entity = finishNode(node);
@@ -3639,7 +3639,7 @@ namespace ts {
             let elementName: EntityName = parseIdentifierName();
             while (parseOptional(SyntaxKind.DotToken)) {
                 scanJsxIdentifier();
-                const node = <QualifiedName>createNode(SyntaxKind.QualifiedName, elementName.pos);
+                const node: QualifiedName = <QualifiedName>createNode(SyntaxKind.QualifiedName, elementName.pos);
                 node.left = elementName;
                 node.right = parseIdentifierName();
                 elementName = finishNode(node);

src/compiler/types.ts

@@ -443,7 +443,8 @@ namespace ts {
         decorators?: NodeArray<Decorator>;              // Array of decorators (in document order)
         modifiers?: ModifiersArray;                     // Array of modifiers
         /* @internal */ id?: number;                    // Unique id (used to look up NodeLinks)
-        parent?: Node;                                  // Parent node (initialized by binding
+        parent?: Node;                                  // Parent node (initialized by binding)
+        previous?: FlowMarkerTarget[];                  // Previous occurencies of flowmarkers (initialized by binding)
         /* @internal */ jsDocComment?: JSDocComment;    // JSDoc for the node, if it has any.  Only for .js files.
         /* @internal */ symbol?: Symbol;                // Symbol declared by node (initialized by binding)
         /* @internal */ locals?: SymbolTable;           // Locals associated with node (initialized by binding)
@@ -459,6 +460,16 @@ namespace ts {
         flags: number;
     }
 
+    export type FlowMarkerTarget = Node | BranchFlow;
+    export type BranchFlowNode = IfStatement | WhileStatement | ForStatement | DoStatement | ConditionalExpression | BinaryExpression
+    export interface BranchFlow {
+        id: number;
+        previous: FlowMarkerTarget[];
+        node: BranchFlowNode;
+        expression: Expression;
+        trueBranch: boolean;
+    }
+
     // @kind(SyntaxKind.AbstractKeyword)
     // @kind(SyntaxKind.AsyncKeyword)
     // @kind(SyntaxKind.ConstKeyword)
@@ -471,6 +482,13 @@ namespace ts {
     // @kind(SyntaxKind.StaticKeyword)
     export interface Modifier extends Node { }
 
+    /* @internal */
+    export enum NarrowingState {
+        Uninitialized,
+        Narrowing,
+        Done,
+        Failed
+    }
     // @kind(SyntaxKind.Identifier)
     export interface Identifier extends PrimaryExpression {
         text: string;                                  // Text of identifier (with escapes converted to characters)
@@ -2095,6 +2113,8 @@ namespace ts {
         resolvedJsxType?: Type;           // resolved element attributes type of a JSX openinglike element
         hasSuperCall?: boolean;           // recorded result when we try to find super-call. We only try to find one if this flag is undefined, indicating that we haven't made an attempt.
         superCall?: ExpressionStatement;  // Cached first super-call found in the constructor. Used in checking whether super is called before this-accessing 
+        narrowingState?: NarrowingState;
+        localType?: Type;
     }
 
     export const enum TypeFlags {

src/compiler/utilities.ts

@@ -1412,7 +1412,7 @@ namespace ts {
     }
 
     // True if the given identifier, string literal, or number literal is the name of a declaration node
-    export function isDeclarationName(name: Node): name is Identifier | StringLiteral | LiteralExpression {
+    export function isDeclarationName(name: Node): name is (Identifier & { __weakTypeGuard: void; }) | StringLiteral | LiteralExpression {
         if (name.kind !== SyntaxKind.Identifier && name.kind !== SyntaxKind.StringLiteral && name.kind !== SyntaxKind.NumericLiteral) {
             return false;
         }

tests/baselines/reference/TypeGuardWithEnumUnion.types

@@ -77,7 +77,7 @@ function f2(x: Color | string | string[]) {
     if (typeof x === "string") {
 >typeof x === "string" : boolean
 >typeof x : string
->x : Color | string | string[]
+>x : string | string[] | Color
 >"string" : string
 
         var a = x;
@@ -89,11 +89,11 @@ function f2(x: Color | string | string[]) {
     }
     else {
         var b = x;
->b : Color | string[]
->x : Color | string[]
+>b : string[] | Color
+>x : string[] | Color
 
         var b: Color | string[];
->b : Color | string[]
+>b : string[] | Color
 >Color : Color
     }
 }

tests/baselines/reference/assignmentTypeNarrowing.js

@@ -0,0 +1,53 @@
+//// [assignmentTypeNarrowing.ts]
+let x: string | number | boolean | RegExp;
+
+x = "";
+x; // string
+
+[x] = [true];
+x; // boolean
+
+[x = ""] = [1];
+x; // string | number
+
+({x} = {x: true});
+x; // boolean
+
+({y: x} = {y: 1});
+x; // number
+
+({x = ""} = {x: true});
+x; // string | boolean
+
+({y: x = /a/} = {y: 1});
+x; // number | RegExp
+
+let a: string[];
+
+for (x of a) {
+    x; // string
+}
+
+
+//// [assignmentTypeNarrowing.js]
+var x;
+x = "";
+x; // string
+x = [true][0];
+x; // boolean
+_a = [1][0], x = _a === void 0 ? "" : _a;
+x; // string | number
+(_b = { x: true }, x = _b.x, _b);
+x; // boolean
+(_c = { y: 1 }, x = _c.y, _c);
+x; // number
+(_d = { x: true }, _e = _d.x, x = _e === void 0 ? "" : _e, _d);
+x; // string | boolean
+(_f = { y: 1 }, _g = _f.y, x = _g === void 0 ? /a/ : _g, _f);
+x; // number | RegExp
+var a;
+for (var _i = 0, a_1 = a; _i < a_1.length; _i++) {
+    x = a_1[_i];
+    x; // string
+}
+var _a, _b, _c, _d, _e, _f, _g;

tests/baselines/reference/assignmentTypeNarrowing.symbols

@@ -0,0 +1,64 @@
+=== tests/cases/conformance/expressions/assignmentOperator/assignmentTypeNarrowing.ts ===
+let x: string | number | boolean | RegExp;
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+x = "";
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+
+x; // string
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+
+[x] = [true];
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+
+x; // boolean
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+
+[x = ""] = [1];
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+
+x; // string | number
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+
+({x} = {x: true});
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 11, 2))
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 11, 8))
+
+x; // boolean
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+
+({y: x} = {y: 1});
+>y : Symbol(y, Decl(assignmentTypeNarrowing.ts, 14, 2))
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+>y : Symbol(y, Decl(assignmentTypeNarrowing.ts, 14, 11))
+
+x; // number
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+
+({x = ""} = {x: true});
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 17, 2))
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 17, 13))
+
+x; // string | boolean
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+
+({y: x = /a/} = {y: 1});
+>y : Symbol(y, Decl(assignmentTypeNarrowing.ts, 20, 2))
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+>y : Symbol(y, Decl(assignmentTypeNarrowing.ts, 20, 17))
+
+x; // number | RegExp
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+
+let a: string[];
+>a : Symbol(a, Decl(assignmentTypeNarrowing.ts, 23, 3))
+
+for (x of a) {
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+>a : Symbol(a, Decl(assignmentTypeNarrowing.ts, 23, 3))
+
+    x; // string
+>x : Symbol(x, Decl(assignmentTypeNarrowing.ts, 0, 3))
+}
+

tests/baselines/reference/assignmentTypeNarrowing.types

@@ -0,0 +1,98 @@
+=== tests/cases/conformance/expressions/assignmentOperator/assignmentTypeNarrowing.ts ===
+let x: string | number | boolean | RegExp;
+>x : string | number | boolean | RegExp
+>RegExp : RegExp
+
+x = "";
+>x = "" : string
+>x : string | number | boolean | RegExp
+>"" : string
+
+x; // string
+>x : string
+
+[x] = [true];
+>[x] = [true] : [boolean]
+>[x] : [string | number | boolean | RegExp]
+>x : string | number | boolean | RegExp
+>[true] : [boolean]
+>true : boolean
+
+x; // boolean
+>x : boolean
+
+[x = ""] = [1];
+>[x = ""] = [1] : [number]
+>[x = ""] : [string]
+>x = "" : string
+>x : string | number | boolean | RegExp
+>"" : string
+>[1] : [number]
+>1 : number
+
+x; // string | number
+>x : string | number
+
+({x} = {x: true});
+>({x} = {x: true}) : { x: boolean; }
+>{x} = {x: true} : { x: boolean; }
+>{x} : { x: string | number | boolean | RegExp; }
+>x : string | number | boolean | RegExp
+>{x: true} : { x: boolean; }
+>x : boolean
+>true : boolean
+
+x; // boolean
+>x : boolean
+
+({y: x} = {y: 1});
+>({y: x} = {y: 1}) : { y: number; }
+>{y: x} = {y: 1} : { y: number; }
+>{y: x} : { y: string | number | boolean | RegExp; }
+>y : string | number | boolean | RegExp
+>x : string | number | boolean | RegExp
+>{y: 1} : { y: number; }
+>y : number
+>1 : number
+
+x; // number
+>x : number
+
+({x = ""} = {x: true});
+>({x = ""} = {x: true}) : { x?: boolean; }
+>{x = ""} = {x: true} : { x?: boolean; }
+>{x = ""} : { x?: string | number | boolean | RegExp; }
+>x : string | number | boolean | RegExp
+>{x: true} : { x?: boolean; }
+>x : boolean
+>true : boolean
+
+x; // string | boolean
+>x : string | boolean
+
+({y: x = /a/} = {y: 1});
+>({y: x = /a/} = {y: 1}) : { y?: number; }
+>{y: x = /a/} = {y: 1} : { y?: number; }
+>{y: x = /a/} : { y?: RegExp; }
+>y : RegExp
+>x = /a/ : RegExp
+>x : string | number | boolean | RegExp
+>/a/ : RegExp
+>{y: 1} : { y?: number; }
+>y : number
+>1 : number
+
+x; // number | RegExp
+>x : number | RegExp
+
+let a: string[];
+>a : string[]
+
+for (x of a) {
+>x : string | number | boolean | RegExp
+>a : string[]
+
+    x; // string
+>x : string
+}
+

tests/baselines/reference/controlFlowAssignmentExpression.js

@@ -0,0 +1,22 @@
+//// [controlFlowAssignmentExpression.ts]
+let x: string | boolean | number;
+let obj: any;
+
+x = "";
+x = x.length;
+x; // number
+
+x = true;
+(x = "", obj).foo = (x = x.length);
+x; // number
+
+
+//// [controlFlowAssignmentExpression.js]
+var x;
+var obj;
+x = "";
+x = x.length;
+x; // number
+x = true;
+(x = "", obj).foo = (x = x.length);
+x; // number

tests/baselines/reference/controlFlowAssignmentExpression.symbols

@@ -0,0 +1,33 @@
+=== tests/cases/conformance/controlFlow/controlFlowAssignmentExpression.ts ===
+let x: string | boolean | number;
+>x : Symbol(x, Decl(controlFlowAssignmentExpression.ts, 0, 3))
+
+let obj: any;
+>obj : Symbol(obj, Decl(controlFlowAssignmentExpression.ts, 1, 3))
+
+x = "";
+>x : Symbol(x, Decl(controlFlowAssignmentExpression.ts, 0, 3))
+
+x = x.length;
+>x : Symbol(x, Decl(controlFlowAssignmentExpression.ts, 0, 3))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>x : Symbol(x, Decl(controlFlowAssignmentExpression.ts, 0, 3))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
+
+x; // number
+>x : Symbol(x, Decl(controlFlowAssignmentExpression.ts, 0, 3))
+
+x = true;
+>x : Symbol(x, Decl(controlFlowAssignmentExpression.ts, 0, 3))
+
+(x = "", obj).foo = (x = x.length);
+>x : Symbol(x, Decl(controlFlowAssignmentExpression.ts, 0, 3))
+>obj : Symbol(obj, Decl(controlFlowAssignmentExpression.ts, 1, 3))
+>x : Symbol(x, Decl(controlFlowAssignmentExpression.ts, 0, 3))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>x : Symbol(x, Decl(controlFlowAssignmentExpression.ts, 0, 3))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
+
+x; // number
+>x : Symbol(x, Decl(controlFlowAssignmentExpression.ts, 0, 3))
+