Accepting new baselines

tests/baselines/reference/TypeGuardWithEnumUnion.types

@@ -55,7 +55,7 @@ function f2(x: Color | string | string[]) {
     if (typeof x === "number") {
 >typeof x === "number" : boolean
 >typeof x : string
->x : Color | string | string[]
+>x : string[] | Color | string
 >"number" : string
 
         var z = x;
@@ -68,16 +68,16 @@ function f2(x: Color | string | string[]) {
     }
     else {
         var w = x;
->w : string | string[]
->x : string | string[]
+>w : string[] | string
+>x : string[] | string
 
         var w: string | string[];
->w : string | string[]
+>w : string[] | string
     }
     if (typeof x === "string") {
 >typeof x === "string" : boolean
 >typeof x : string
->x : Color | string | string[]
+>x : Color | string[] | string
 >"string" : string
 
         var a = x;

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))
+

tests/baselines/reference/controlFlowAssignmentExpression.types

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

tests/baselines/reference/controlFlowBinaryAndExpression.js

@@ -0,0 +1,20 @@
+//// [controlFlowBinaryAndExpression.ts]
+let x: string | number | boolean;
+let cond: boolean;
+
+(x = "") && (x = 0);
+x; // string | number
+
+x = "";
+cond && (x = 0);
+x; // string | number
+
+
+//// [controlFlowBinaryAndExpression.js]
+var x;
+var cond;
+(x = "") && (x = 0);
+x; // string | number
+x = "";
+cond && (x = 0);
+x; // string | number

tests/baselines/reference/controlFlowBinaryAndExpression.symbols

@@ -0,0 +1,24 @@
+=== tests/cases/conformance/controlFlow/controlFlowBinaryAndExpression.ts ===
+let x: string | number | boolean;
+>x : Symbol(x, Decl(controlFlowBinaryAndExpression.ts, 0, 3))
+
+let cond: boolean;
+>cond : Symbol(cond, Decl(controlFlowBinaryAndExpression.ts, 1, 3))
+
+(x = "") && (x = 0);
+>x : Symbol(x, Decl(controlFlowBinaryAndExpression.ts, 0, 3))
+>x : Symbol(x, Decl(controlFlowBinaryAndExpression.ts, 0, 3))
+
+x; // string | number
+>x : Symbol(x, Decl(controlFlowBinaryAndExpression.ts, 0, 3))
+
+x = "";
+>x : Symbol(x, Decl(controlFlowBinaryAndExpression.ts, 0, 3))
+
+cond && (x = 0);
+>cond : Symbol(cond, Decl(controlFlowBinaryAndExpression.ts, 1, 3))
+>x : Symbol(x, Decl(controlFlowBinaryAndExpression.ts, 0, 3))
+
+x; // string | number
+>x : Symbol(x, Decl(controlFlowBinaryAndExpression.ts, 0, 3))
+

tests/baselines/reference/controlFlowBinaryAndExpression.types

@@ -0,0 +1,37 @@
+=== tests/cases/conformance/controlFlow/controlFlowBinaryAndExpression.ts ===
+let x: string | number | boolean;
+>x : string | number | boolean
+
+let cond: boolean;
+>cond : boolean
+
+(x = "") && (x = 0);
+>(x = "") && (x = 0) : number
+>(x = "") : string
+>x = "" : string
+>x : string | number | boolean
+>"" : string
+>(x = 0) : number
+>x = 0 : number
+>x : string | number | boolean
+>0 : number
+
+x; // string | number
+>x : string | number
+
+x = "";
+>x = "" : string
+>x : string | number | boolean
+>"" : string
+
+cond && (x = 0);
+>cond && (x = 0) : number
+>cond : boolean
+>(x = 0) : number
+>x = 0 : number
+>x : string | number | boolean
+>0 : number
+
+x; // string | number
+>x : string | number
+

tests/baselines/reference/controlFlowBinaryOrExpression.js

@@ -0,0 +1,20 @@
+//// [controlFlowBinaryOrExpression.ts]
+let x: string | number | boolean;
+let cond: boolean;
+
+(x = "") || (x = 0);
+x; // string | number
+
+x = "";
+cond || (x = 0);
+x; // string | number
+
+
+//// [controlFlowBinaryOrExpression.js]
+var x;
+var cond;
+(x = "") || (x = 0);
+x; // string | number
+x = "";
+cond || (x = 0);
+x; // string | number

tests/baselines/reference/controlFlowBinaryOrExpression.symbols

@@ -0,0 +1,24 @@
+=== tests/cases/conformance/controlFlow/controlFlowBinaryOrExpression.ts ===
+let x: string | number | boolean;
+>x : Symbol(x, Decl(controlFlowBinaryOrExpression.ts, 0, 3))
+
+let cond: boolean;
+>cond : Symbol(cond, Decl(controlFlowBinaryOrExpression.ts, 1, 3))
+
+(x = "") || (x = 0);
+>x : Symbol(x, Decl(controlFlowBinaryOrExpression.ts, 0, 3))
+>x : Symbol(x, Decl(controlFlowBinaryOrExpression.ts, 0, 3))
+
+x; // string | number
+>x : Symbol(x, Decl(controlFlowBinaryOrExpression.ts, 0, 3))
+
+x = "";
+>x : Symbol(x, Decl(controlFlowBinaryOrExpression.ts, 0, 3))
+
+cond || (x = 0);
+>cond : Symbol(cond, Decl(controlFlowBinaryOrExpression.ts, 1, 3))
+>x : Symbol(x, Decl(controlFlowBinaryOrExpression.ts, 0, 3))
+
+x; // string | number
+>x : Symbol(x, Decl(controlFlowBinaryOrExpression.ts, 0, 3))
+

tests/baselines/reference/controlFlowBinaryOrExpression.types

@@ -0,0 +1,37 @@
+=== tests/cases/conformance/controlFlow/controlFlowBinaryOrExpression.ts ===
+let x: string | number | boolean;
+>x : string | number | boolean
+
+let cond: boolean;
+>cond : boolean
+
+(x = "") || (x = 0);
+>(x = "") || (x = 0) : string | number
+>(x = "") : string
+>x = "" : string
+>x : string | number | boolean
+>"" : string
+>(x = 0) : number
+>x = 0 : number
+>x : string | number | boolean
+>0 : number
+
+x; // string | number
+>x : string | number
+
+x = "";
+>x = "" : string
+>x : string | number | boolean
+>"" : string
+
+cond || (x = 0);
+>cond || (x = 0) : boolean | number
+>cond : boolean
+>(x = 0) : number
+>x = 0 : number
+>x : string | number | boolean
+>0 : number
+
+x; // string | number
+>x : string | number
+

tests/baselines/reference/controlFlowConditionalExpression.js

@@ -0,0 +1,13 @@
+//// [controlFlowConditionalExpression.ts]
+let x: string | number | boolean;
+let cond: boolean;
+
+cond ? x = "" : x = 3;
+x; // string | number
+
+
+//// [controlFlowConditionalExpression.js]
+var x;
+var cond;
+cond ? x = "" : x = 3;
+x; // string | number

tests/baselines/reference/controlFlowConditionalExpression.symbols

@@ -0,0 +1,15 @@
+=== tests/cases/conformance/controlFlow/controlFlowConditionalExpression.ts ===
+let x: string | number | boolean;
+>x : Symbol(x, Decl(controlFlowConditionalExpression.ts, 0, 3))
+
+let cond: boolean;
+>cond : Symbol(cond, Decl(controlFlowConditionalExpression.ts, 1, 3))
+
+cond ? x = "" : x = 3;
+>cond : Symbol(cond, Decl(controlFlowConditionalExpression.ts, 1, 3))
+>x : Symbol(x, Decl(controlFlowConditionalExpression.ts, 0, 3))
+>x : Symbol(x, Decl(controlFlowConditionalExpression.ts, 0, 3))
+
+x; // string | number
+>x : Symbol(x, Decl(controlFlowConditionalExpression.ts, 0, 3))
+

tests/baselines/reference/controlFlowConditionalExpression.types

@@ -0,0 +1,20 @@
+=== tests/cases/conformance/controlFlow/controlFlowConditionalExpression.ts ===
+let x: string | number | boolean;
+>x : string | number | boolean
+
+let cond: boolean;
+>cond : boolean
+
+cond ? x = "" : x = 3;
+>cond ? x = "" : x = 3 : string | number
+>cond : boolean
+>x = "" : string
+>x : string | number | boolean
+>"" : string
+>x = 3 : number
+>x : string | number | boolean
+>3 : number
+
+x; // string | number
+>x : string | number
+

tests/baselines/reference/controlFlowDoWhileStatement.js

@@ -0,0 +1,157 @@
+//// [controlFlowDoWhileStatement.ts]
+let cond: boolean;
+function a() {
+    let x: string | number;
+    x = "";
+    do {
+        x; // string
+    } while (cond)
+}
+function b() {
+    let x: string | number;
+    x = "";
+    do {
+        x; // string
+        x = 42;
+        break;
+    } while (cond)
+}
+function c() {
+    let x: string | number;
+    x = "";
+    do {
+        x; // string
+        x = undefined;
+        if (typeof x === "string") continue;
+        break;
+    } while (cond)
+}
+function d() {
+    let x: string | number;
+    x = 1000;
+    do {
+        x; // number
+        x = "";
+    } while (x = x.length)
+    x; // number
+}
+function e() {
+    let x: string | number;
+    x = "";
+    do {
+        x = 42;
+    } while (cond)
+    x; // number
+}
+function f() {
+    let x: string | number | boolean | RegExp | Function;
+    x = "";
+    do {
+        if (cond) {
+            x = 42;
+            break;
+        }
+        if (cond) {
+            x = true;
+            continue;
+        }
+        x = /a/;
+    } while (cond)
+    x; // number | boolean | RegExp
+}
+function g() {
+    let x: string | number | boolean | RegExp | Function;
+    x = "";
+    do {
+        if (cond) {
+            x = 42;
+            break;
+        }
+        if (cond) {
+            x = true;
+            continue;
+        }
+        x = /a/;
+    } while (true)
+    x; // number
+}
+
+
+//// [controlFlowDoWhileStatement.js]
+var cond;
+function a() {
+    var x;
+    x = "";
+    do {
+        x; // string
+    } while (cond);
+}
+function b() {
+    var x;
+    x = "";
+    do {
+        x; // string
+        x = 42;
+        break;
+    } while (cond);
+}
+function c() {
+    var x;
+    x = "";
+    do {
+        x; // string
+        x = undefined;
+        if (typeof x === "string")
+            continue;
+        break;
+    } while (cond);
+}
+function d() {
+    var x;
+    x = 1000;
+    do {
+        x; // number
+        x = "";
+    } while (x = x.length);
+    x; // number
+}
+function e() {
+    var x;
+    x = "";
+    do {
+        x = 42;
+    } while (cond);
+    x; // number
+}
+function f() {
+    var x;
+    x = "";
+    do {
+        if (cond) {
+            x = 42;
+            break;
+        }
+        if (cond) {
+            x = true;
+            continue;
+        }
+        x = /a/;
+    } while (cond);
+    x; // number | boolean | RegExp
+}
+function g() {
+    var x;
+    x = "";
+    do {
+        if (cond) {
+            x = 42;
+            break;
+        }
+        if (cond) {
+            x = true;
+            continue;
+        }
+        x = /a/;
+    } while (true);
+    x; // number
+}

tests/baselines/reference/controlFlowDoWhileStatement.symbols

@@ -0,0 +1,181 @@
+=== tests/cases/conformance/controlFlow/controlFlowDoWhileStatement.ts ===
+let cond: boolean;
+>cond : Symbol(cond, Decl(controlFlowDoWhileStatement.ts, 0, 3))
+
+function a() {
+>a : Symbol(a, Decl(controlFlowDoWhileStatement.ts, 0, 18))
+
+    let x: string | number;
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 2, 7))
+
+    x = "";
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 2, 7))
+
+    do {
+        x; // string
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 2, 7))
+
+    } while (cond)
+>cond : Symbol(cond, Decl(controlFlowDoWhileStatement.ts, 0, 3))
+}
+function b() {
+>b : Symbol(b, Decl(controlFlowDoWhileStatement.ts, 7, 1))
+
+    let x: string | number;
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 9, 7))
+
+    x = "";
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 9, 7))
+
+    do {
+        x; // string
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 9, 7))
+
+        x = 42;
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 9, 7))
+
+        break;
+    } while (cond)
+>cond : Symbol(cond, Decl(controlFlowDoWhileStatement.ts, 0, 3))
+}
+function c() {
+>c : Symbol(c, Decl(controlFlowDoWhileStatement.ts, 16, 1))
+
+    let x: string | number;
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 18, 7))
+
+    x = "";
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 18, 7))
+
+    do {
+        x; // string
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 18, 7))
+
+        x = undefined;
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 18, 7))
+>undefined : Symbol(undefined)
+
+        if (typeof x === "string") continue;
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 18, 7))
+
+        break;
+    } while (cond)
+>cond : Symbol(cond, Decl(controlFlowDoWhileStatement.ts, 0, 3))
+}
+function d() {
+>d : Symbol(d, Decl(controlFlowDoWhileStatement.ts, 26, 1))
+
+    let x: string | number;
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 28, 7))
+
+    x = 1000;
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 28, 7))
+
+    do {
+        x; // number
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 28, 7))
+
+        x = "";
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 28, 7))
+
+    } while (x = x.length)
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 28, 7))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 28, 7))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
+
+    x; // number
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 28, 7))
+}
+function e() {
+>e : Symbol(e, Decl(controlFlowDoWhileStatement.ts, 35, 1))
+
+    let x: string | number;
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 37, 7))
+
+    x = "";
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 37, 7))
+
+    do {
+        x = 42;
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 37, 7))
+
+    } while (cond)
+>cond : Symbol(cond, Decl(controlFlowDoWhileStatement.ts, 0, 3))
+
+    x; // number
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 37, 7))
+}
+function f() {
+>f : Symbol(f, Decl(controlFlowDoWhileStatement.ts, 43, 1))
+
+    let x: string | number | boolean | RegExp | Function;
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 45, 7))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+    x = "";
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 45, 7))
+
+    do {
+        if (cond) {
+>cond : Symbol(cond, Decl(controlFlowDoWhileStatement.ts, 0, 3))
+
+            x = 42;
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 45, 7))
+
+            break;
+        }
+        if (cond) {
+>cond : Symbol(cond, Decl(controlFlowDoWhileStatement.ts, 0, 3))
+
+            x = true;
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 45, 7))
+
+            continue;
+        }
+        x = /a/;
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 45, 7))
+
+    } while (cond)
+>cond : Symbol(cond, Decl(controlFlowDoWhileStatement.ts, 0, 3))
+
+    x; // number | boolean | RegExp
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 45, 7))
+}
+function g() {
+>g : Symbol(g, Decl(controlFlowDoWhileStatement.ts, 59, 1))
+
+    let x: string | number | boolean | RegExp | Function;
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 61, 7))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+    x = "";
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 61, 7))
+
+    do {
+        if (cond) {
+>cond : Symbol(cond, Decl(controlFlowDoWhileStatement.ts, 0, 3))
+
+            x = 42;
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 61, 7))
+
+            break;
+        }
+        if (cond) {
+>cond : Symbol(cond, Decl(controlFlowDoWhileStatement.ts, 0, 3))
+
+            x = true;
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 61, 7))
+
+            continue;
+        }
+        x = /a/;
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 61, 7))
+
+    } while (true)
+    x; // number
+>x : Symbol(x, Decl(controlFlowDoWhileStatement.ts, 61, 7))
+}
+

tests/baselines/reference/controlFlowDoWhileStatement.types

@@ -0,0 +1,220 @@
+=== tests/cases/conformance/controlFlow/controlFlowDoWhileStatement.ts ===
+let cond: boolean;
+>cond : boolean
+
+function a() {
+>a : () => void
+
+    let x: string | number;
+>x : string | number
+
+    x = "";
+>x = "" : string
+>x : string | number
+>"" : string
+
+    do {
+        x; // string
+>x : string
+
+    } while (cond)
+>cond : boolean
+}
+function b() {
+>b : () => void
+
+    let x: string | number;
+>x : string | number
+
+    x = "";
+>x = "" : string
+>x : string | number
+>"" : string
+
+    do {
+        x; // string
+>x : string
+
+        x = 42;
+>x = 42 : number
+>x : string | number
+>42 : number
+
+        break;
+    } while (cond)
+>cond : boolean
+}
+function c() {
+>c : () => void
+
+    let x: string | number;
+>x : string | number
+
+    x = "";
+>x = "" : string
+>x : string | number
+>"" : string
+
+    do {
+        x; // string
+>x : string
+
+        x = undefined;
+>x = undefined : undefined
+>x : string | number
+>undefined : undefined
+
+        if (typeof x === "string") continue;
+>typeof x === "string" : boolean
+>typeof x : string
+>x : string | number
+>"string" : string
+
+        break;
+    } while (cond)
+>cond : boolean
+}
+function d() {
+>d : () => void
+
+    let x: string | number;
+>x : string | number
+
+    x = 1000;
+>x = 1000 : number
+>x : string | number
+>1000 : number
+
+    do {
+        x; // number
+>x : number
+
+        x = "";
+>x = "" : string
+>x : string | number
+>"" : string
+
+    } while (x = x.length)
+>x = x.length : number
+>x : string | number
+>x.length : number
+>x : string
+>length : number
+
+    x; // number
+>x : number
+}
+function e() {
+>e : () => void
+
+    let x: string | number;
+>x : string | number
+
+    x = "";
+>x = "" : string
+>x : string | number
+>"" : string
+
+    do {
+        x = 42;
+>x = 42 : number
+>x : string | number
+>42 : number
+
+    } while (cond)
+>cond : boolean
+
+    x; // number
+>x : number
+}
+function f() {
+>f : () => void
+
+    let x: string | number | boolean | RegExp | Function;
+>x : string | number | boolean | RegExp | Function
+>RegExp : RegExp
+>Function : Function
+
+    x = "";
+>x = "" : string
+>x : string | number | boolean | RegExp | Function
+>"" : string
+
+    do {
+        if (cond) {
+>cond : boolean
+
+            x = 42;
+>x = 42 : number
+>x : string | number | boolean | RegExp | Function
+>42 : number
+
+            break;
+        }
+        if (cond) {
+>cond : boolean
+
+            x = true;
+>x = true : boolean
+>x : string | number | boolean | RegExp | Function
+>true : boolean
+
+            continue;
+        }
+        x = /a/;
+>x = /a/ : RegExp
+>x : string | number | boolean | RegExp | Function
+>/a/ : RegExp
+
+    } while (cond)
+>cond : boolean
+
+    x; // number | boolean | RegExp
+>x : number | boolean | RegExp
+}
+function g() {
+>g : () => void
+
+    let x: string | number | boolean | RegExp | Function;
+>x : string | number | boolean | RegExp | Function
+>RegExp : RegExp
+>Function : Function
+
+    x = "";
+>x = "" : string
+>x : string | number | boolean | RegExp | Function
+>"" : string
+
+    do {
+        if (cond) {
+>cond : boolean
+
+            x = 42;
+>x = 42 : number
+>x : string | number | boolean | RegExp | Function
+>42 : number
+
+            break;
+        }
+        if (cond) {
+>cond : boolean
+
+            x = true;
+>x = true : boolean
+>x : string | number | boolean | RegExp | Function
+>true : boolean
+
+            continue;
+        }
+        x = /a/;
+>x = /a/ : RegExp
+>x : string | number | boolean | RegExp | Function
+>/a/ : RegExp
+
+    } while (true)
+>true : boolean
+
+    x; // number
+>x : number
+}
+

tests/baselines/reference/controlFlowForInStatement.js

@@ -0,0 +1,37 @@
+//// [controlFlowForInStatement.ts]
+let x: string | number | boolean | RegExp | Function;
+let obj: any;
+let cond: boolean;
+
+x = /a/;
+for (let y in obj) {
+    x = y;
+    if (cond) {
+        x = 42;
+        continue;
+    }
+    if (cond) {
+        x = true;
+        break;
+    }
+}
+x; // RegExp | string | number | boolean
+
+
+//// [controlFlowForInStatement.js]
+var x;
+var obj;
+var cond;
+x = /a/;
+for (var y in obj) {
+    x = y;
+    if (cond) {
+        x = 42;
+        continue;
+    }
+    if (cond) {
+        x = true;
+        break;
+    }
+}
+x; // RegExp | string | number | boolean

tests/baselines/reference/controlFlowForInStatement.symbols

@@ -0,0 +1,43 @@
+=== tests/cases/conformance/controlFlow/controlFlowForInStatement.ts ===
+let x: string | number | boolean | RegExp | Function;
+>x : Symbol(x, Decl(controlFlowForInStatement.ts, 0, 3))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+let obj: any;
+>obj : Symbol(obj, Decl(controlFlowForInStatement.ts, 1, 3))
+
+let cond: boolean;
+>cond : Symbol(cond, Decl(controlFlowForInStatement.ts, 2, 3))
+
+x = /a/;
+>x : Symbol(x, Decl(controlFlowForInStatement.ts, 0, 3))
+
+for (let y in obj) {
+>y : Symbol(y, Decl(controlFlowForInStatement.ts, 5, 8))
+>obj : Symbol(obj, Decl(controlFlowForInStatement.ts, 1, 3))
+
+    x = y;
+>x : Symbol(x, Decl(controlFlowForInStatement.ts, 0, 3))
+>y : Symbol(y, Decl(controlFlowForInStatement.ts, 5, 8))
+
+    if (cond) {
+>cond : Symbol(cond, Decl(controlFlowForInStatement.ts, 2, 3))
+
+        x = 42;
+>x : Symbol(x, Decl(controlFlowForInStatement.ts, 0, 3))
+
+        continue;
+    }
+    if (cond) {
+>cond : Symbol(cond, Decl(controlFlowForInStatement.ts, 2, 3))
+
+        x = true;
+>x : Symbol(x, Decl(controlFlowForInStatement.ts, 0, 3))
+
+        break;
+    }
+}
+x; // RegExp | string | number | boolean
+>x : Symbol(x, Decl(controlFlowForInStatement.ts, 0, 3))
+

tests/baselines/reference/controlFlowForInStatement.types

@@ -0,0 +1,50 @@
+=== tests/cases/conformance/controlFlow/controlFlowForInStatement.ts ===
+let x: string | number | boolean | RegExp | Function;
+>x : string | number | boolean | RegExp | Function
+>RegExp : RegExp
+>Function : Function
+
+let obj: any;
+>obj : any
+
+let cond: boolean;
+>cond : boolean
+
+x = /a/;
+>x = /a/ : RegExp
+>x : string | number | boolean | RegExp | Function
+>/a/ : RegExp
+
+for (let y in obj) {
+>y : string
+>obj : any
+
+    x = y;
+>x = y : string
+>x : string | number | boolean | RegExp | Function
+>y : string
+
+    if (cond) {
+>cond : boolean
+
+        x = 42;
+>x = 42 : number
+>x : string | number | boolean | RegExp | Function
+>42 : number
+
+        continue;
+    }
+    if (cond) {
+>cond : boolean
+
+        x = true;
+>x = true : boolean
+>x : string | number | boolean | RegExp | Function
+>true : boolean
+
+        break;
+    }
+}
+x; // RegExp | string | number | boolean
+>x : RegExp | number | string | boolean
+

tests/baselines/reference/controlFlowForOfStatement.js

@@ -0,0 +1,24 @@
+//// [controlFlowForOfStatement.ts]
+let obj: number[];
+let x: string | number | boolean | RegExp;
+
+function a() {
+    x = true;
+    for (x of obj) {
+        x = x.toExponential();
+    }
+    x; // string | boolean
+}
+
+
+//// [controlFlowForOfStatement.js]
+var obj;
+var x;
+function a() {
+    x = true;
+    for (var _i = 0, obj_1 = obj; _i < obj_1.length; _i++) {
+        x = obj_1[_i];
+        x = x.toExponential();
+    }
+    x; // string | boolean
+}

tests/baselines/reference/controlFlowForOfStatement.symbols

@@ -0,0 +1,28 @@
+=== tests/cases/conformance/controlFlow/controlFlowForOfStatement.ts ===
+let obj: number[];
+>obj : Symbol(obj, Decl(controlFlowForOfStatement.ts, 0, 3))
+
+let x: string | number | boolean | RegExp;
+>x : Symbol(x, Decl(controlFlowForOfStatement.ts, 1, 3))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+function a() {
+>a : Symbol(a, Decl(controlFlowForOfStatement.ts, 1, 42))
+
+    x = true;
+>x : Symbol(x, Decl(controlFlowForOfStatement.ts, 1, 3))
+
+    for (x of obj) {
+>x : Symbol(x, Decl(controlFlowForOfStatement.ts, 1, 3))
+>obj : Symbol(obj, Decl(controlFlowForOfStatement.ts, 0, 3))
+
+        x = x.toExponential();
+>x : Symbol(x, Decl(controlFlowForOfStatement.ts, 1, 3))
+>x.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --))
+>x : Symbol(x, Decl(controlFlowForOfStatement.ts, 1, 3))
+>toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --))
+    }
+    x; // string | boolean
+>x : Symbol(x, Decl(controlFlowForOfStatement.ts, 1, 3))
+}
+

tests/baselines/reference/controlFlowForOfStatement.types

@@ -0,0 +1,32 @@
+=== tests/cases/conformance/controlFlow/controlFlowForOfStatement.ts ===
+let obj: number[];
+>obj : number[]
+
+let x: string | number | boolean | RegExp;
+>x : string | number | boolean | RegExp
+>RegExp : RegExp
+
+function a() {
+>a : () => void
+
+    x = true;
+>x = true : boolean
+>x : string | number | boolean | RegExp
+>true : boolean
+
+    for (x of obj) {
+>x : string | number | boolean | RegExp
+>obj : number[]
+
+        x = x.toExponential();
+>x = x.toExponential() : string
+>x : string | number | boolean | RegExp
+>x.toExponential() : string
+>x.toExponential : (fractionDigits?: number) => string
+>x : number
+>toExponential : (fractionDigits?: number) => string
+    }
+    x; // string | boolean
+>x : boolean | string
+}
+

tests/baselines/reference/controlFlowForStatement.js

@@ -0,0 +1,87 @@
+//// [controlFlowForStatement.ts]
+let cond: boolean;
+function a() {
+    let x: string | number | boolean;
+    for (x = ""; cond; x = 5) {
+        x; // string | number
+    }
+}
+function b() {
+    let x: string | number | boolean;
+    for (x = 5; cond; x = x.length) {
+        x; // number
+        x = "";
+    }
+}
+function c() {
+    let x: string | number | boolean;
+    for (x = 5; x = x.toExponential(); x = 5) {
+        x; // string
+    }
+}
+function d() {
+    let x: string | number | boolean;
+    for (x = ""; typeof x === "string"; x = 5) {
+        x; // string
+    }
+}
+function e() {
+    let x: string | number | boolean | RegExp;
+    for (x = "" || 0; typeof x !== "string"; x = "" || true) {
+        x; // number | boolean
+    }
+}
+function f() {
+    let x: string | number | boolean;
+    for (; typeof x !== "string";) {
+        x; // number | boolean
+        if (typeof x === "number") break;
+        x = undefined;
+    }
+    x; // string | number
+}
+
+
+//// [controlFlowForStatement.js]
+var cond;
+function a() {
+    var x;
+    for (x = ""; cond; x = 5) {
+        x; // string | number
+    }
+}
+function b() {
+    var x;
+    for (x = 5; cond; x = x.length) {
+        x; // number
+        x = "";
+    }
+}
+function c() {
+    var x;
+    for (x = 5; x = x.toExponential(); x = 5) {
+        x; // string
+    }
+}
+function d() {
+    var x;
+    for (x = ""; typeof x === "string"; x = 5) {
+        x; // string
+    }
+}
+function e() {
+    var x;
+    for (x = "" || 0; typeof x !== "string"; x = "" || true) {
+        x; // number | boolean
+    }
+}
+function f() {
+    var x;
+    for (; typeof x !== "string";) {
+        x; // number | boolean
+        if (typeof x === "number")
+            break;
+        x = undefined;
+    }
+    x; // string | number
+}

tests/baselines/reference/controlFlowForStatement.symbols

@@ -0,0 +1,112 @@
+=== tests/cases/conformance/controlFlow/controlFlowForStatement.ts ===
+let cond: boolean;
+>cond : Symbol(cond, Decl(controlFlowForStatement.ts, 0, 3))
+
+function a() {
+>a : Symbol(a, Decl(controlFlowForStatement.ts, 0, 18))
+
+    let x: string | number | boolean;
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 2, 7))
+
+    for (x = ""; cond; x = 5) {
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 2, 7))
+>cond : Symbol(cond, Decl(controlFlowForStatement.ts, 0, 3))
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 2, 7))
+
+        x; // string | number
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 2, 7))
+    }
+}
+function b() {
+>b : Symbol(b, Decl(controlFlowForStatement.ts, 6, 1))
+
+    let x: string | number | boolean;
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 8, 7))
+
+    for (x = 5; cond; x = x.length) {
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 8, 7))
+>cond : Symbol(cond, Decl(controlFlowForStatement.ts, 0, 3))
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 8, 7))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 8, 7))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
+
+        x; // number
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 8, 7))
+
+        x = "";
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 8, 7))
+    }
+}
+function c() {
+>c : Symbol(c, Decl(controlFlowForStatement.ts, 13, 1))
+
+    let x: string | number | boolean;
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 15, 7))
+
+    for (x = 5; x = x.toExponential(); x = 5) {
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 15, 7))
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 15, 7))
+>x.toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --))
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 15, 7))
+>toExponential : Symbol(Number.toExponential, Decl(lib.d.ts, --, --))
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 15, 7))
+
+        x; // string
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 15, 7))
+    }
+}
+function d() {
+>d : Symbol(d, Decl(controlFlowForStatement.ts, 19, 1))
+
+    let x: string | number | boolean;
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 21, 7))
+
+    for (x = ""; typeof x === "string"; x = 5) {
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 21, 7))
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 21, 7))
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 21, 7))
+
+        x; // string
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 21, 7))
+    }
+}
+function e() {
+>e : Symbol(e, Decl(controlFlowForStatement.ts, 25, 1))
+
+    let x: string | number | boolean | RegExp;
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 27, 7))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+    for (x = "" || 0; typeof x !== "string"; x = "" || true) {
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 27, 7))
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 27, 7))
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 27, 7))
+
+        x; // number | boolean
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 27, 7))
+    }
+}
+function f() {
+>f : Symbol(f, Decl(controlFlowForStatement.ts, 31, 1))
+
+    let x: string | number | boolean;
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 33, 7))
+
+    for (; typeof x !== "string";) {
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 33, 7))
+
+        x; // number | boolean
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 33, 7))
+
+        if (typeof x === "number") break;
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 33, 7))
+
+        x = undefined;
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 33, 7))
+>undefined : Symbol(undefined)
+    }
+    x; // string | number
+>x : Symbol(x, Decl(controlFlowForStatement.ts, 33, 7))
+}
+

tests/baselines/reference/controlFlowForStatement.types

@@ -0,0 +1,152 @@
+=== tests/cases/conformance/controlFlow/controlFlowForStatement.ts ===
+let cond: boolean;
+>cond : boolean
+
+function a() {
+>a : () => void
+
+    let x: string | number | boolean;
+>x : string | number | boolean
+
+    for (x = ""; cond; x = 5) {
+>x = "" : string
+>x : string | number | boolean
+>"" : string
+>cond : boolean
+>x = 5 : number
+>x : string | number | boolean
+>5 : number
+
+        x; // string | number
+>x : string | number
+    }
+}
+function b() {
+>b : () => void
+
+    let x: string | number | boolean;
+>x : string | number | boolean
+
+    for (x = 5; cond; x = x.length) {
+>x = 5 : number
+>x : string | number | boolean
+>5 : number
+>cond : boolean
+>x = x.length : number
+>x : string | number | boolean
+>x.length : number
+>x : string
+>length : number
+
+        x; // number
+>x : number
+
+        x = "";
+>x = "" : string
+>x : string | number | boolean
+>"" : string
+    }
+}
+function c() {
+>c : () => void
+
+    let x: string | number | boolean;
+>x : string | number | boolean
+
+    for (x = 5; x = x.toExponential(); x = 5) {
+>x = 5 : number
+>x : string | number | boolean
+>5 : number
+>x = x.toExponential() : string
+>x : string | number | boolean
+>x.toExponential() : string
+>x.toExponential : (fractionDigits?: number) => string
+>x : number
+>toExponential : (fractionDigits?: number) => string
+>x = 5 : number
+>x : string | number | boolean
+>5 : number
+
+        x; // string
+>x : string
+    }
+}
+function d() {
+>d : () => void
+
+    let x: string | number | boolean;
+>x : string | number | boolean
+
+    for (x = ""; typeof x === "string"; x = 5) {
+>x = "" : string
+>x : string | number | boolean
+>"" : string
+>typeof x === "string" : boolean
+>typeof x : string
+>x : string | number
+>"string" : string
+>x = 5 : number
+>x : string | number | boolean
+>5 : number
+
+        x; // string
+>x : string
+    }
+}
+function e() {
+>e : () => void
+
+    let x: string | number | boolean | RegExp;
+>x : string | number | boolean | RegExp
+>RegExp : RegExp
+
+    for (x = "" || 0; typeof x !== "string"; x = "" || true) {
+>x = "" || 0 : string | number
+>x : string | number | boolean | RegExp
+>"" || 0 : string | number
+>"" : string
+>0 : number
+>typeof x !== "string" : boolean
+>typeof x : string
+>x : string | number | boolean
+>"string" : string
+>x = "" || true : string | boolean
+>x : string | number | boolean | RegExp
+>"" || true : string | boolean
+>"" : string
+>true : boolean
+
+        x; // number | boolean
+>x : number | boolean
+    }
+}
+function f() {
+>f : () => void
+
+    let x: string | number | boolean;
+>x : string | number | boolean
+
+    for (; typeof x !== "string";) {
+>typeof x !== "string" : boolean
+>typeof x : string
+>x : string | number | boolean
+>"string" : string
+
+        x; // number | boolean
+>x : number | boolean
+
+        if (typeof x === "number") break;
+>typeof x === "number" : boolean
+>typeof x : string
+>x : number | boolean
+>"number" : string
+
+        x = undefined;
+>x = undefined : undefined
+>x : string | number | boolean
+>undefined : undefined
+    }
+    x; // string | number
+>x : string | number
+}
+

tests/baselines/reference/controlFlowIfStatement.js

@@ -0,0 +1,74 @@
+//// [controlFlowIfStatement.ts]
+let x: string | number | boolean | RegExp;
+let cond: boolean;
+
+x = /a/;
+if (x /* RegExp */, (x = true)) {
+    x; // boolean
+    x = "";
+}
+else {
+    x; // boolean
+    x = 42;
+}
+x; // string | number
+
+function a() {
+    let x: string | number;
+    if (cond) {
+        x = 42;
+    }
+    else {
+        x = "";
+        return;
+    }
+    x; // number
+}
+function b() {
+    let x: string | number;
+    if (cond) {
+        x = 42;
+        throw "";
+    }
+    else {
+        x = "";
+    }
+    x; // string
+}
+
+
+//// [controlFlowIfStatement.js]
+var x;
+var cond;
+x = /a/;
+if (x /* RegExp */, (x = true)) {
+    x; // boolean
+    x = "";
+}
+else {
+    x; // boolean
+    x = 42;
+}
+x; // string | number
+function a() {
+    var x;
+    if (cond) {
+        x = 42;
+    }
+    else {
+        x = "";
+        return;
+    }
+    x; // number
+}
+function b() {
+    var x;
+    if (cond) {
+        x = 42;
+        throw "";
+    }
+    else {
+        x = "";
+    }
+    x; // string
+}

tests/baselines/reference/controlFlowIfStatement.symbols

@@ -0,0 +1,74 @@
+=== tests/cases/conformance/controlFlow/controlFlowIfStatement.ts ===
+let x: string | number | boolean | RegExp;
+>x : Symbol(x, Decl(controlFlowIfStatement.ts, 0, 3))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+let cond: boolean;
+>cond : Symbol(cond, Decl(controlFlowIfStatement.ts, 1, 3))
+
+x = /a/;
+>x : Symbol(x, Decl(controlFlowIfStatement.ts, 0, 3))
+
+if (x /* RegExp */, (x = true)) {
+>x : Symbol(x, Decl(controlFlowIfStatement.ts, 0, 3))
+>x : Symbol(x, Decl(controlFlowIfStatement.ts, 0, 3))
+
+    x; // boolean
+>x : Symbol(x, Decl(controlFlowIfStatement.ts, 0, 3))
+
+    x = "";
+>x : Symbol(x, Decl(controlFlowIfStatement.ts, 0, 3))
+}
+else {
+    x; // boolean
+>x : Symbol(x, Decl(controlFlowIfStatement.ts, 0, 3))
+
+    x = 42;
+>x : Symbol(x, Decl(controlFlowIfStatement.ts, 0, 3))
+}
+x; // string | number
+>x : Symbol(x, Decl(controlFlowIfStatement.ts, 0, 3))
+
+function a() {
+>a : Symbol(a, Decl(controlFlowIfStatement.ts, 12, 2))
+
+    let x: string | number;
+>x : Symbol(x, Decl(controlFlowIfStatement.ts, 15, 7))
+
+    if (cond) {
+>cond : Symbol(cond, Decl(controlFlowIfStatement.ts, 1, 3))
+
+        x = 42;
+>x : Symbol(x, Decl(controlFlowIfStatement.ts, 15, 7))
+    }
+    else {
+        x = "";
+>x : Symbol(x, Decl(controlFlowIfStatement.ts, 15, 7))
+
+        return;
+    }
+    x; // number
+>x : Symbol(x, Decl(controlFlowIfStatement.ts, 15, 7))
+}
+function b() {
+>b : Symbol(b, Decl(controlFlowIfStatement.ts, 24, 1))
+
+    let x: string | number;
+>x : Symbol(x, Decl(controlFlowIfStatement.ts, 26, 7))
+
+    if (cond) {
+>cond : Symbol(cond, Decl(controlFlowIfStatement.ts, 1, 3))
+
+        x = 42;
+>x : Symbol(x, Decl(controlFlowIfStatement.ts, 26, 7))
+
+        throw "";
+    }
+    else {
+        x = "";
+>x : Symbol(x, Decl(controlFlowIfStatement.ts, 26, 7))
+    }
+    x; // string
+>x : Symbol(x, Decl(controlFlowIfStatement.ts, 26, 7))
+}
+

tests/baselines/reference/controlFlowIfStatement.types

@@ -0,0 +1,93 @@
+=== tests/cases/conformance/controlFlow/controlFlowIfStatement.ts ===
+let x: string | number | boolean | RegExp;
+>x : string | number | boolean | RegExp
+>RegExp : RegExp
+
+let cond: boolean;
+>cond : boolean
+
+x = /a/;
+>x = /a/ : RegExp
+>x : string | number | boolean | RegExp
+>/a/ : RegExp
+
+if (x /* RegExp */, (x = true)) {
+>x /* RegExp */, (x = true) : boolean
+>x : RegExp
+>(x = true) : boolean
+>x = true : boolean
+>x : string | number | boolean | RegExp
+>true : boolean
+
+    x; // boolean
+>x : boolean
+
+    x = "";
+>x = "" : string
+>x : string | number | boolean | RegExp
+>"" : string
+}
+else {
+    x; // boolean
+>x : boolean
+
+    x = 42;
+>x = 42 : number
+>x : string | number | boolean | RegExp
+>42 : number
+}
+x; // string | number
+>x : string | number
+
+function a() {
+>a : () => void
+
+    let x: string | number;
+>x : string | number
+
+    if (cond) {
+>cond : boolean
+
+        x = 42;
+>x = 42 : number
+>x : string | number
+>42 : number
+    }
+    else {
+        x = "";
+>x = "" : string
+>x : string | number
+>"" : string
+
+        return;
+    }
+    x; // number
+>x : number
+}
+function b() {
+>b : () => void
+
+    let x: string | number;
+>x : string | number
+
+    if (cond) {
+>cond : boolean
+
+        x = 42;
+>x = 42 : number
+>x : string | number
+>42 : number
+
+        throw "";
+>"" : string
+    }
+    else {
+        x = "";
+>x = "" : string
+>x : string | number
+>"" : string
+    }
+    x; // string
+>x : string
+}
+

tests/baselines/reference/controlFlowWhileStatement.js

@@ -0,0 +1,155 @@
+//// [controlFlowWhileStatement.ts]
+let cond: boolean;
+function a() {
+    let x: string | number;
+    x = "";
+    while (cond) {
+        x; // string
+    }
+}
+function b() {
+    let x: string | number;
+    x = "";
+    while (cond) {
+        x; // string
+        x = 42;
+        break;
+    }
+}
+function c() {
+    let x: string | number;
+    x = "";
+    while (cond) {
+        x; // string
+        x = undefined;
+        if (typeof x === "string") continue;
+        break;
+    }
+}
+function d() {
+    let x: string | number;
+    x = "";
+    while (x = x.length) {
+        x; // number
+        x = "";
+    }
+}
+function e() {
+    let x: string | number;
+    x = "";
+    while (cond) {
+        x = 42;
+    }
+    x; // string | number
+}
+function f() {
+    let x: string | number | boolean | RegExp | Function;
+    x = "";
+    while (cond) {
+        if (cond) {
+            x = 42;
+            break;
+        }
+        if (cond) {
+            x = true;
+            continue;
+        }
+        x = /a/;
+    }
+    x; // string | number | boolean | RegExp
+}
+function g() {
+    let x: string | number | boolean | RegExp | Function;
+    x = "";
+    while (true) {
+        if (cond) {
+            x = 42;
+            break;
+        }
+        if (cond) {
+            x = true;
+            continue;
+        }
+        x = /a/;
+    }
+    x; // number
+}
+
+
+//// [controlFlowWhileStatement.js]
+var cond;
+function a() {
+    var x;
+    x = "";
+    while (cond) {
+        x; // string
+    }
+}
+function b() {
+    var x;
+    x = "";
+    while (cond) {
+        x; // string
+        x = 42;
+        break;
+    }
+}
+function c() {
+    var x;
+    x = "";
+    while (cond) {
+        x; // string
+        x = undefined;
+        if (typeof x === "string")
+            continue;
+        break;
+    }
+}
+function d() {
+    var x;
+    x = "";
+    while (x = x.length) {
+        x; // number
+        x = "";
+    }
+}
+function e() {
+    var x;
+    x = "";
+    while (cond) {
+        x = 42;
+    }
+    x; // string | number
+}
+function f() {
+    var x;
+    x = "";
+    while (cond) {
+        if (cond) {
+            x = 42;
+            break;
+        }
+        if (cond) {
+            x = true;
+            continue;
+        }
+        x = /a/;
+    }
+    x; // string | number | boolean | RegExp
+}
+function g() {
+    var x;
+    x = "";
+    while (true) {
+        if (cond) {
+            x = 42;
+            break;
+        }
+        if (cond) {
+            x = true;
+            continue;
+        }
+        x = /a/;
+    }
+    x; // number
+}

tests/baselines/reference/controlFlowWhileStatement.symbols

@@ -0,0 +1,177 @@
+=== tests/cases/conformance/controlFlow/controlFlowWhileStatement.ts ===
+let cond: boolean;
+>cond : Symbol(cond, Decl(controlFlowWhileStatement.ts, 0, 3))
+
+function a() {
+>a : Symbol(a, Decl(controlFlowWhileStatement.ts, 0, 18))
+
+    let x: string | number;
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 2, 7))
+
+    x = "";
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 2, 7))
+
+    while (cond) {
+>cond : Symbol(cond, Decl(controlFlowWhileStatement.ts, 0, 3))
+
+        x; // string
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 2, 7))
+    }
+}
+function b() {
+>b : Symbol(b, Decl(controlFlowWhileStatement.ts, 7, 1))
+
+    let x: string | number;
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 9, 7))
+
+    x = "";
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 9, 7))
+
+    while (cond) {
+>cond : Symbol(cond, Decl(controlFlowWhileStatement.ts, 0, 3))
+
+        x; // string
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 9, 7))
+
+        x = 42;
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 9, 7))
+
+        break;
+    }
+}
+function c() {
+>c : Symbol(c, Decl(controlFlowWhileStatement.ts, 16, 1))
+
+    let x: string | number;
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 18, 7))
+
+    x = "";
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 18, 7))
+
+    while (cond) {
+>cond : Symbol(cond, Decl(controlFlowWhileStatement.ts, 0, 3))
+
+        x; // string
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 18, 7))
+
+        x = undefined;
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 18, 7))
+>undefined : Symbol(undefined)
+
+        if (typeof x === "string") continue;
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 18, 7))
+
+        break;
+    }
+}
+function d() {
+>d : Symbol(d, Decl(controlFlowWhileStatement.ts, 26, 1))
+
+    let x: string | number;
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 28, 7))
+
+    x = "";
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 28, 7))
+
+    while (x = x.length) {
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 28, 7))
+>x.length : Symbol(String.length, Decl(lib.d.ts, --, --))
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 28, 7))
+>length : Symbol(String.length, Decl(lib.d.ts, --, --))
+
+        x; // number
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 28, 7))
+
+        x = "";
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 28, 7))
+    }
+}
+function e() {
+>e : Symbol(e, Decl(controlFlowWhileStatement.ts, 34, 1))
+
+    let x: string | number;
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 36, 7))
+
+    x = "";
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 36, 7))
+
+    while (cond) {
+>cond : Symbol(cond, Decl(controlFlowWhileStatement.ts, 0, 3))
+
+        x = 42;
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 36, 7))
+    }
+    x; // string | number
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 36, 7))
+}
+function f() {
+>f : Symbol(f, Decl(controlFlowWhileStatement.ts, 42, 1))
+
+    let x: string | number | boolean | RegExp | Function;
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 44, 7))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+    x = "";
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 44, 7))
+
+    while (cond) {
+>cond : Symbol(cond, Decl(controlFlowWhileStatement.ts, 0, 3))
+
+        if (cond) {
+>cond : Symbol(cond, Decl(controlFlowWhileStatement.ts, 0, 3))
+
+            x = 42;
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 44, 7))
+
+            break;
+        }
+        if (cond) {
+>cond : Symbol(cond, Decl(controlFlowWhileStatement.ts, 0, 3))
+
+            x = true;
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 44, 7))
+
+            continue;
+        }
+        x = /a/;
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 44, 7))
+    }
+    x; // string | number | boolean | RegExp
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 44, 7))
+}
+function g() {
+>g : Symbol(g, Decl(controlFlowWhileStatement.ts, 58, 1))
+
+    let x: string | number | boolean | RegExp | Function;
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 60, 7))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+>Function : Symbol(Function, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
+
+    x = "";
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 60, 7))
+
+    while (true) {
+        if (cond) {
+>cond : Symbol(cond, Decl(controlFlowWhileStatement.ts, 0, 3))
+
+            x = 42;
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 60, 7))
+
+            break;
+        }
+        if (cond) {
+>cond : Symbol(cond, Decl(controlFlowWhileStatement.ts, 0, 3))
+
+            x = true;
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 60, 7))
+
+            continue;
+        }
+        x = /a/;
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 60, 7))
+    }
+    x; // number
+>x : Symbol(x, Decl(controlFlowWhileStatement.ts, 60, 7))
+}
+

tests/baselines/reference/controlFlowWhileStatement.types

@@ -0,0 +1,216 @@
+=== tests/cases/conformance/controlFlow/controlFlowWhileStatement.ts ===
+let cond: boolean;
+>cond : boolean
+
+function a() {
+>a : () => void
+
+    let x: string | number;
+>x : string | number
+
+    x = "";
+>x = "" : string
+>x : string | number
+>"" : string
+
+    while (cond) {
+>cond : boolean
+
+        x; // string
+>x : string
+    }
+}
+function b() {
+>b : () => void
+
+    let x: string | number;
+>x : string | number
+
+    x = "";
+>x = "" : string
+>x : string | number
+>"" : string
+
+    while (cond) {
+>cond : boolean
+
+        x; // string
+>x : string
+
+        x = 42;
+>x = 42 : number
+>x : string | number
+>42 : number
+
+        break;
+    }
+}
+function c() {
+>c : () => void
+
+    let x: string | number;
+>x : string | number
+
+    x = "";
+>x = "" : string
+>x : string | number
+>"" : string
+
+    while (cond) {
+>cond : boolean
+
+        x; // string
+>x : string
+
+        x = undefined;
+>x = undefined : undefined
+>x : string | number
+>undefined : undefined
+
+        if (typeof x === "string") continue;
+>typeof x === "string" : boolean
+>typeof x : string
+>x : string | number
+>"string" : string
+
+        break;
+    }
+}
+function d() {
+>d : () => void
+
+    let x: string | number;
+>x : string | number
+
+    x = "";
+>x = "" : string
+>x : string | number
+>"" : string
+
+    while (x = x.length) {
+>x = x.length : number
+>x : string | number
+>x.length : number
+>x : string
+>length : number
+
+        x; // number
+>x : number
+
+        x = "";
+>x = "" : string
+>x : string | number
+>"" : string
+    }
+}
+function e() {
+>e : () => void
+
+    let x: string | number;
+>x : string | number
+
+    x = "";
+>x = "" : string
+>x : string | number
+>"" : string
+
+    while (cond) {
+>cond : boolean
+
+        x = 42;
+>x = 42 : number
+>x : string | number
+>42 : number
+    }
+    x; // string | number
+>x : string | number
+}
+function f() {
+>f : () => void
+
+    let x: string | number | boolean | RegExp | Function;
+>x : string | number | boolean | RegExp | Function
+>RegExp : RegExp
+>Function : Function
+
+    x = "";
+>x = "" : string
+>x : string | number | boolean | RegExp | Function
+>"" : string
+
+    while (cond) {
+>cond : boolean
+
+        if (cond) {
+>cond : boolean
+
+            x = 42;
+>x = 42 : number
+>x : string | number | boolean | RegExp | Function
+>42 : number
+
+            break;
+        }
+        if (cond) {
+>cond : boolean
+
+            x = true;
+>x = true : boolean
+>x : string | number | boolean | RegExp | Function
+>true : boolean
+
+            continue;
+        }
+        x = /a/;
+>x = /a/ : RegExp
+>x : string | number | boolean | RegExp | Function
+>/a/ : RegExp
+    }
+    x; // string | number | boolean | RegExp
+>x : string | boolean | RegExp | number
+}
+function g() {
+>g : () => void
+
+    let x: string | number | boolean | RegExp | Function;
+>x : string | number | boolean | RegExp | Function
+>RegExp : RegExp
+>Function : Function
+
+    x = "";
+>x = "" : string
+>x : string | number | boolean | RegExp | Function
+>"" : string
+
+    while (true) {
+>true : boolean
+
+        if (cond) {
+>cond : boolean
+
+            x = 42;
+>x = 42 : number
+>x : string | number | boolean | RegExp | Function
+>42 : number
+
+            break;
+        }
+        if (cond) {
+>cond : boolean
+
+            x = true;
+>x = true : boolean
+>x : string | number | boolean | RegExp | Function
+>true : boolean
+
+            continue;
+        }
+        x = /a/;
+>x = /a/ : RegExp
+>x : string | number | boolean | RegExp | Function
+>/a/ : RegExp
+    }
+    x; // number
+>x : number
+}
+

tests/baselines/reference/for-of45.types

@@ -13,7 +13,7 @@ var map = new Map([["", true]]);
 >true : boolean
 
 for ([k = "", v = false] of map) {
->[k = "", v = false] : (string | boolean)[]
+>[k = "", v = false] : [string, boolean]
 >k = "" : string
 >k : string
 >"" : string

tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPattern2.types

@@ -93,7 +93,7 @@ let numberA3: number, robotAInfo: (number | string)[], multiRobotAInfo: (string
 >multiRobotAInfo : (string | [string, string])[]
 
 for ([, nameA] of robots) {
->[, nameA] : string[]
+>[, nameA] : [undefined, string]
 > : undefined
 >nameA : string
 >robots : [number, string, string][]
@@ -106,7 +106,7 @@ for ([, nameA] of robots) {
 >nameA : string
 }
 for ([, nameA] of getRobots()) {
->[, nameA] : string[]
+>[, nameA] : [undefined, string]
 > : undefined
 >nameA : string
 >getRobots() : [number, string, string][]
@@ -120,7 +120,7 @@ for ([, nameA] of getRobots()) {
 >nameA : string
 }
 for ([, nameA] of [robotA, robotB]) {
->[, nameA] : string[]
+>[, nameA] : [undefined, string]
 > : undefined
 >nameA : string
 >[robotA, robotB] : [number, string, string][]
@@ -135,9 +135,9 @@ for ([, nameA] of [robotA, robotB]) {
 >nameA : string
 }
 for ([, [primarySkillA, secondarySkillA]] of multiRobots) {
->[, [primarySkillA, secondarySkillA]] : string[][]
+>[, [primarySkillA, secondarySkillA]] : [undefined, [string, string]]
 > : undefined
->[primarySkillA, secondarySkillA] : string[]
+>[primarySkillA, secondarySkillA] : [string, string]
 >primarySkillA : string
 >secondarySkillA : string
 >multiRobots : [string, [string, string]][]
@@ -150,9 +150,9 @@ for ([, [primarySkillA, secondarySkillA]] of multiRobots) {
 >primarySkillA : string
 }
 for ([, [primarySkillA, secondarySkillA]] of getMultiRobots()) {
->[, [primarySkillA, secondarySkillA]] : string[][]
+>[, [primarySkillA, secondarySkillA]] : [undefined, [string, string]]
 > : undefined
->[primarySkillA, secondarySkillA] : string[]
+>[primarySkillA, secondarySkillA] : [string, string]
 >primarySkillA : string
 >secondarySkillA : string
 >getMultiRobots() : [string, [string, string]][]
@@ -166,9 +166,9 @@ for ([, [primarySkillA, secondarySkillA]] of getMultiRobots()) {
 >primarySkillA : string
 }
 for ([, [primarySkillA, secondarySkillA]] of [multiRobotA, multiRobotB]) {
->[, [primarySkillA, secondarySkillA]] : string[][]
+>[, [primarySkillA, secondarySkillA]] : [undefined, [string, string]]
 > : undefined
->[primarySkillA, secondarySkillA] : string[]
+>[primarySkillA, secondarySkillA] : [string, string]
 >primarySkillA : string
 >secondarySkillA : string
 >[multiRobotA, multiRobotB] : [string, [string, string]][]
@@ -184,7 +184,7 @@ for ([, [primarySkillA, secondarySkillA]] of [multiRobotA, multiRobotB]) {
 }
 
 for ([numberB] of robots) {
->[numberB] : number[]
+>[numberB] : [number]
 >numberB : number
 >robots : [number, string, string][]
 
@@ -196,7 +196,7 @@ for ([numberB] of robots) {
 >numberB : number
 }
 for ([numberB] of getRobots()) {
->[numberB] : number[]
+>[numberB] : [number]
 >numberB : number
 >getRobots() : [number, string, string][]
 >getRobots : () => [number, string, string][]
@@ -209,7 +209,7 @@ for ([numberB] of getRobots()) {
 >numberB : number
 }
 for ([numberB] of [robotA, robotB]) {
->[numberB] : number[]
+>[numberB] : [number]
 >numberB : number
 >[robotA, robotB] : [number, string, string][]
 >robotA : [number, string, string]
@@ -223,7 +223,7 @@ for ([numberB] of [robotA, robotB]) {
 >numberB : number
 }
 for ([nameB] of multiRobots) {
->[nameB] : string[]
+>[nameB] : [string]
 >nameB : string
 >multiRobots : [string, [string, string]][]
 
@@ -235,7 +235,7 @@ for ([nameB] of multiRobots) {
 >nameB : string
 }
 for ([nameB] of getMultiRobots()) {
->[nameB] : string[]
+>[nameB] : [string]
 >nameB : string
 >getMultiRobots() : [string, [string, string]][]
 >getMultiRobots : () => [string, [string, string]][]
@@ -248,7 +248,7 @@ for ([nameB] of getMultiRobots()) {
 >nameB : string
 }
 for ([nameB] of [multiRobotA, multiRobotB]) {
->[nameB] : string[]
+>[nameB] : [string]
 >nameB : string
 >[multiRobotA, multiRobotB] : [string, [string, string]][]
 >multiRobotA : [string, [string, string]]
@@ -263,7 +263,7 @@ for ([nameB] of [multiRobotA, multiRobotB]) {
 }
 
 for ([numberA2, nameA2, skillA2] of robots) {
->[numberA2, nameA2, skillA2] : (number | string)[]
+>[numberA2, nameA2, skillA2] : [number, string, string]
 >numberA2 : number
 >nameA2 : string
 >skillA2 : string
@@ -277,7 +277,7 @@ for ([numberA2, nameA2, skillA2] of robots) {
 >nameA2 : string
 }
 for ([numberA2, nameA2, skillA2] of getRobots()) {
->[numberA2, nameA2, skillA2] : (number | string)[]
+>[numberA2, nameA2, skillA2] : [number, string, string]
 >numberA2 : number
 >nameA2 : string
 >skillA2 : string
@@ -292,7 +292,7 @@ for ([numberA2, nameA2, skillA2] of getRobots()) {
 >nameA2 : string
 }
 for ([numberA2, nameA2, skillA2] of [robotA, robotB]) {
->[numberA2, nameA2, skillA2] : (number | string)[]
+>[numberA2, nameA2, skillA2] : [number, string, string]
 >numberA2 : number
 >nameA2 : string
 >skillA2 : string
@@ -308,9 +308,9 @@ for ([numberA2, nameA2, skillA2] of [robotA, robotB]) {
 >nameA2 : string
 }
 for ([nameMA, [primarySkillA, secondarySkillA]] of multiRobots) {
->[nameMA, [primarySkillA, secondarySkillA]] : (string | string[])[]
+>[nameMA, [primarySkillA, secondarySkillA]] : [string, [string, string]]
 >nameMA : string
->[primarySkillA, secondarySkillA] : string[]
+>[primarySkillA, secondarySkillA] : [string, string]
 >primarySkillA : string
 >secondarySkillA : string
 >multiRobots : [string, [string, string]][]
@@ -323,9 +323,9 @@ for ([nameMA, [primarySkillA, secondarySkillA]] of multiRobots) {
 >nameMA : string
 }
 for ([nameMA, [primarySkillA, secondarySkillA]] of getMultiRobots()) {
->[nameMA, [primarySkillA, secondarySkillA]] : (string | string[])[]
+>[nameMA, [primarySkillA, secondarySkillA]] : [string, [string, string]]
 >nameMA : string
->[primarySkillA, secondarySkillA] : string[]
+>[primarySkillA, secondarySkillA] : [string, string]
 >primarySkillA : string
 >secondarySkillA : string
 >getMultiRobots() : [string, [string, string]][]
@@ -339,9 +339,9 @@ for ([nameMA, [primarySkillA, secondarySkillA]] of getMultiRobots()) {
 >nameMA : string
 }
 for ([nameMA, [primarySkillA, secondarySkillA]] of [multiRobotA, multiRobotB]) {
->[nameMA, [primarySkillA, secondarySkillA]] : (string | string[])[]
+>[nameMA, [primarySkillA, secondarySkillA]] : [string, [string, string]]
 >nameMA : string
->[primarySkillA, secondarySkillA] : string[]
+>[primarySkillA, secondarySkillA] : [string, string]
 >primarySkillA : string
 >secondarySkillA : string
 >[multiRobotA, multiRobotB] : [string, [string, string]][]

tests/baselines/reference/sourceMapValidationDestructuringForOfArrayBindingPatternDefaultValues2.types

@@ -93,7 +93,7 @@ let numberA3: number, robotAInfo: (number | string)[], multiRobotAInfo: (string
 >multiRobotAInfo : (string | [string, string])[]
 
 for ([, nameA = "noName"] of robots) {
->[, nameA = "noName"] : string[]
+>[, nameA = "noName"] : [undefined, string]
 > : undefined
 >nameA = "noName" : string
 >nameA : string
@@ -108,7 +108,7 @@ for ([, nameA = "noName"] of robots) {
 >nameA : string
 }
 for ([, nameA = "noName"] of getRobots()) {
->[, nameA = "noName"] : string[]
+>[, nameA = "noName"] : [undefined, string]
 > : undefined
 >nameA = "noName" : string
 >nameA : string
@@ -124,7 +124,7 @@ for ([, nameA = "noName"] of getRobots()) {
 >nameA : string
 }
 for ([, nameA = "noName"] of [robotA, robotB]) {
->[, nameA = "noName"] : string[]
+>[, nameA = "noName"] : [undefined, string]
 > : undefined
 >nameA = "noName" : string
 >nameA : string
@@ -141,7 +141,7 @@ for ([, nameA = "noName"] of [robotA, robotB]) {
 >nameA : string
 }
 for ([, [
->[, [    primarySkillA = "primary",    secondarySkillA = "secondary"] = ["skill1", "skill2"]] : [string, string][]
+>[, [    primarySkillA = "primary",    secondarySkillA = "secondary"] = ["skill1", "skill2"]] : [undefined, [string, string]]
 > : undefined
 >[    primarySkillA = "primary",    secondarySkillA = "secondary"] = ["skill1", "skill2"] : [string, string]
 >[    primarySkillA = "primary",    secondarySkillA = "secondary"] : [string, string]
@@ -170,7 +170,7 @@ for ([, [
 >primarySkillA : string
 }
 for ([, [
->[, [    primarySkillA = "primary",    secondarySkillA = "secondary"] = ["skill1", "skill2"]] : [string, string][]
+>[, [    primarySkillA = "primary",    secondarySkillA = "secondary"] = ["skill1", "skill2"]] : [undefined, [string, string]]
 > : undefined
 >[    primarySkillA = "primary",    secondarySkillA = "secondary"] = ["skill1", "skill2"] : [string, string]
 >[    primarySkillA = "primary",    secondarySkillA = "secondary"] : [string, string]
@@ -200,7 +200,7 @@ for ([, [
 >primarySkillA : string
 }
 for ([, [
->[, [    primarySkillA = "primary",    secondarySkillA = "secondary"] = ["skill1", "skill2"]] : [string, string][]
+>[, [    primarySkillA = "primary",    secondarySkillA = "secondary"] = ["skill1", "skill2"]] : [undefined, [string, string]]
 > : undefined
 >[    primarySkillA = "primary",    secondarySkillA = "secondary"] = ["skill1", "skill2"] : [string, string]
 >[    primarySkillA = "primary",    secondarySkillA = "secondary"] : [string, string]
@@ -232,7 +232,7 @@ for ([, [
 }
 
 for ([numberB = -1] of robots) {
->[numberB = -1] : number[]
+>[numberB = -1] : [number]
 >numberB = -1 : number
 >numberB : number
 >-1 : number
@@ -247,7 +247,7 @@ for ([numberB = -1] of robots) {
 >numberB : number
 }
 for ([numberB = -1] of getRobots()) {
->[numberB = -1] : number[]
+>[numberB = -1] : [number]
 >numberB = -1 : number
 >numberB : number
 >-1 : number
@@ -263,7 +263,7 @@ for ([numberB = -1] of getRobots()) {
 >numberB : number
 }
 for ([numberB = -1] of [robotA, robotB]) {
->[numberB = -1] : number[]
+>[numberB = -1] : [number]
 >numberB = -1 : number
 >numberB : number
 >-1 : number
@@ -280,7 +280,7 @@ for ([numberB = -1] of [robotA, robotB]) {
 >numberB : number
 }
 for ([nameB = "noName"] of multiRobots) {
->[nameB = "noName"] : string[]
+>[nameB = "noName"] : [string]
 >nameB = "noName" : string
 >nameB : string
 >"noName" : string
@@ -294,7 +294,7 @@ for ([nameB = "noName"] of multiRobots) {
 >nameB : string
 }
 for ([nameB = "noName"] of getMultiRobots()) {
->[nameB = "noName"] : string[]
+>[nameB = "noName"] : [string]
 >nameB = "noName" : string
 >nameB : string
 >"noName" : string
@@ -309,7 +309,7 @@ for ([nameB = "noName"] of getMultiRobots()) {
 >nameB : string
 }
 for ([nameB = "noName"] of [multiRobotA, multiRobotB]) {
->[nameB = "noName"] : string[]
+>[nameB = "noName"] : [string]
 >nameB = "noName" : string
 >nameB : string
 >"noName" : string
@@ -326,7 +326,7 @@ for ([nameB = "noName"] of [multiRobotA, multiRobotB]) {
 }
 
 for ([numberA2 = -1, nameA2 = "noName", skillA2 = "skill"] of robots) {
->[numberA2 = -1, nameA2 = "noName", skillA2 = "skill"] : (number | string)[]
+>[numberA2 = -1, nameA2 = "noName", skillA2 = "skill"] : [number, string, string]
 >numberA2 = -1 : number
 >numberA2 : number
 >-1 : number
@@ -347,7 +347,7 @@ for ([numberA2 = -1, nameA2 = "noName", skillA2 = "skill"] of robots) {
 >nameA2 : string
 }
 for ([numberA2 = -1, nameA2 = "noName", skillA2 = "skill"] of getRobots()) {
->[numberA2 = -1, nameA2 = "noName", skillA2 = "skill"] : (number | string)[]
+>[numberA2 = -1, nameA2 = "noName", skillA2 = "skill"] : [number, string, string]
 >numberA2 = -1 : number
 >numberA2 : number
 >-1 : number
@@ -369,7 +369,7 @@ for ([numberA2 = -1, nameA2 = "noName", skillA2 = "skill"] of getRobots()) {
 >nameA2 : string
 }
 for ([numberA2 = -1, nameA2 = "noName", skillA2 = "skill"] of [robotA, robotB]) {
->[numberA2 = -1, nameA2 = "noName", skillA2 = "skill"] : (number | string)[]
+>[numberA2 = -1, nameA2 = "noName", skillA2 = "skill"] : [number, string, string]
 >numberA2 = -1 : number
 >numberA2 : number
 >-1 : number
@@ -392,7 +392,7 @@ for ([numberA2 = -1, nameA2 = "noName", skillA2 = "skill"] of [robotA, robotB])
 >nameA2 : string
 }
 for ([nameMA = "noName", [
->[nameMA = "noName", [    primarySkillA = "primary",    secondarySkillA = "secondary"] = ["skill1", "skill2"]] : (string | [string, string])[]
+>[nameMA = "noName", [    primarySkillA = "primary",    secondarySkillA = "secondary"] = ["skill1", "skill2"]] : [string, [string, string]]
 >nameMA = "noName" : string
 >nameMA : string
 >"noName" : string
@@ -423,7 +423,7 @@ for ([nameMA = "noName", [
 >nameMA : string
 }
 for ([nameMA = "noName", [
->[nameMA = "noName", [    primarySkillA = "primary",    secondarySkillA = "secondary"] = ["skill1", "skill2"]] : (string | [string, string])[]
+>[nameMA = "noName", [    primarySkillA = "primary",    secondarySkillA = "secondary"] = ["skill1", "skill2"]] : [string, [string, string]]
 >nameMA = "noName" : string
 >nameMA : string
 >"noName" : string
@@ -455,7 +455,7 @@ for ([nameMA = "noName", [
 >nameMA : string
 }
 for ([nameMA = "noName", [
->[nameMA = "noName", [    primarySkillA = "primary",    secondarySkillA = "secondary"] = ["skill1", "skill2"]] : (string | [string, string])[]
+>[nameMA = "noName", [    primarySkillA = "primary",    secondarySkillA = "secondary"] = ["skill1", "skill2"]] : [string, [string, string]]
 >nameMA = "noName" : string
 >nameMA : string
 >"noName" : string

tests/baselines/reference/sourceMapValidationDestructuringForOfObjectBindingPatternDefaultValues2.types

@@ -102,7 +102,7 @@ let name: string, primary: string, secondary: string, skill: string;
 >skill : string
 
 for ({name: nameA = "noName" } of robots) {
->{name: nameA = "noName" } : { name: string; }
+>{name: nameA = "noName" } : { name?: string; }
 >name : Robot
 >nameA = "noName" : string
 >nameA : string
@@ -117,7 +117,7 @@ for ({name: nameA = "noName" } of robots) {
 >nameA : string
 }
 for ({name: nameA = "noName" } of getRobots()) {
->{name: nameA = "noName" } : { name: string; }
+>{name: nameA = "noName" } : { name?: string; }
 >name : Robot
 >nameA = "noName" : string
 >nameA : string
@@ -133,7 +133,7 @@ for ({name: nameA = "noName" } of getRobots()) {
 >nameA : string
 }
 for ({name: nameA = "noName" } of [{ name: "mower", skill: "mowing" }, { name: "trimmer", skill: "trimming" }]) {
->{name: nameA = "noName" } : { name: string; }
+>{name: nameA = "noName" } : { name?: string; }
 >name : { name: string; skill: string; }
 >nameA = "noName" : string
 >nameA : string
@@ -158,7 +158,7 @@ for ({name: nameA = "noName" } of [{ name: "mower", skill: "mowing" }, { name: "
 >nameA : string
 }
 for ({ skills: { primary: primaryA = "primary", secondary: secondaryA = "secondary" } =
->{ skills: { primary: primaryA = "primary", secondary: secondaryA = "secondary" } =    { primary: "nosKill", secondary: "noSkill" } } : { skills: { primary?: string; secondary?: string; }; }
+>{ skills: { primary: primaryA = "primary", secondary: secondaryA = "secondary" } =    { primary: "nosKill", secondary: "noSkill" } } : { skills?: { primary?: string; secondary?: string; }; }
 >skills : MultiRobot
 >{ primary: primaryA = "primary", secondary: secondaryA = "secondary" } =    { primary: "nosKill", secondary: "noSkill" } : { primary?: string; secondary?: string; }
 >{ primary: primaryA = "primary", secondary: secondaryA = "secondary" } : { primary?: string; secondary?: string; }
@@ -187,7 +187,7 @@ for ({ skills: { primary: primaryA = "primary", secondary: secondaryA = "seconda
 >primaryA : string
 }
 for ({ skills: { primary: primaryA = "primary", secondary: secondaryA = "secondary" } =
->{ skills: { primary: primaryA = "primary", secondary: secondaryA = "secondary" } =    { primary: "nosKill", secondary: "noSkill" } } : { skills: { primary?: string; secondary?: string; }; }
+>{ skills: { primary: primaryA = "primary", secondary: secondaryA = "secondary" } =    { primary: "nosKill", secondary: "noSkill" } } : { skills?: { primary?: string; secondary?: string; }; }
 >skills : MultiRobot
 >{ primary: primaryA = "primary", secondary: secondaryA = "secondary" } =    { primary: "nosKill", secondary: "noSkill" } : { primary?: string; secondary?: string; }
 >{ primary: primaryA = "primary", secondary: secondaryA = "secondary" } : { primary?: string; secondary?: string; }
@@ -217,7 +217,7 @@ for ({ skills: { primary: primaryA = "primary", secondary: secondaryA = "seconda
 >primaryA : string
 }
 for ({ skills: { primary: primaryA = "primary", secondary: secondaryA = "secondary" } =
->{ skills: { primary: primaryA = "primary", secondary: secondaryA = "secondary" } =    { primary: "nosKill", secondary: "noSkill" } } : { skills: { primary?: string; secondary?: string; }; }
+>{ skills: { primary: primaryA = "primary", secondary: secondaryA = "secondary" } =    { primary: "nosKill", secondary: "noSkill" } } : { skills?: { primary?: string; secondary?: string; }; }
 >skills : MultiRobot
 >{ primary: primaryA = "primary", secondary: secondaryA = "secondary" } =    { primary: "nosKill", secondary: "noSkill" } : { primary?: string; secondary?: string; }
 >{ primary: primaryA = "primary", secondary: secondaryA = "secondary" } : { primary?: string; secondary?: string; }
@@ -271,7 +271,7 @@ for ({ skills: { primary: primaryA = "primary", secondary: secondaryA = "seconda
 }
 
 for ({ name = "noName" } of robots) {
->{ name = "noName" } : { name: string; }
+>{ name = "noName" } : { name?: string; }
 >name : Robot
 >robots : Robot[]
 
@@ -283,7 +283,7 @@ for ({ name = "noName" } of robots) {
 >nameA : string
 }
 for ({ name = "noName" } of getRobots()) {
->{ name = "noName" } : { name: string; }
+>{ name = "noName" } : { name?: string; }
 >name : Robot
 >getRobots() : Robot[]
 >getRobots : () => Robot[]
@@ -296,7 +296,7 @@ for ({ name = "noName" } of getRobots()) {
 >nameA : string
 }
 for ({ name = "noName" } of [{ name: "mower", skill: "mowing" }, { name: "trimmer", skill: "trimming" }]) {
->{ name = "noName" } : { name: string; }
+>{ name = "noName" } : { name?: string; }
 >name : { name: string; skill: string; }
 >[{ name: "mower", skill: "mowing" }, { name: "trimmer", skill: "trimming" }] : { name: string; skill: string; }[]
 >{ name: "mower", skill: "mowing" } : { name: string; skill: string; }
@@ -318,7 +318,7 @@ for ({ name = "noName" } of [{ name: "mower", skill: "mowing" }, { name: "trimme
 >nameA : string
 }
 for ({
->{    skills: {        primary = "primary",        secondary = "secondary"    } = { primary: "noSkill", secondary: "noSkill" }} : { skills: { primary?: string; secondary?: string; }; }
+>{    skills: {        primary = "primary",        secondary = "secondary"    } = { primary: "noSkill", secondary: "noSkill" }} : { skills?: { primary?: string; secondary?: string; }; }
 
     skills: {
 >skills : MultiRobot
@@ -349,7 +349,7 @@ for ({
 >primaryA : string
 }
 for ({
->{    skills: {        primary = "primary",        secondary = "secondary"    } = { primary: "noSkill", secondary: "noSkill" }} : { skills: { primary?: string; secondary?: string; }; }
+>{    skills: {        primary = "primary",        secondary = "secondary"    } = { primary: "noSkill", secondary: "noSkill" }} : { skills?: { primary?: string; secondary?: string; }; }
 
     skills: {
 >skills : MultiRobot
@@ -381,7 +381,7 @@ for ({
 >primaryA : string
 }
 for ({
->{    skills: {        primary = "primary",        secondary = "secondary"    } = { primary: "noSkill", secondary: "noSkill" }} : { skills: { primary?: string; secondary?: string; }; }
+>{    skills: {        primary = "primary",        secondary = "secondary"    } = { primary: "noSkill", secondary: "noSkill" }} : { skills?: { primary?: string; secondary?: string; }; }
 
     skills: {
 >skills : { name: string; skills: { primary: string; secondary: string; }; }
@@ -434,7 +434,7 @@ for ({
 
 
 for ({name: nameA = "noName", skill: skillA = "noSkill" } of robots) {
->{name: nameA = "noName", skill: skillA = "noSkill" } : { name: string; skill: string; }
+>{name: nameA = "noName", skill: skillA = "noSkill" } : { name?: string; skill?: string; }
 >name : Robot
 >nameA = "noName" : string
 >nameA : string
@@ -453,7 +453,7 @@ for ({name: nameA = "noName", skill: skillA = "noSkill" } of robots) {
 >nameA : string
 }
 for ({name: nameA = "noName", skill: skillA = "noSkill"  } of getRobots()) {
->{name: nameA = "noName", skill: skillA = "noSkill"  } : { name: string; skill: string; }
+>{name: nameA = "noName", skill: skillA = "noSkill"  } : { name?: string; skill?: string; }
 >name : Robot
 >nameA = "noName" : string
 >nameA : string
@@ -473,7 +473,7 @@ for ({name: nameA = "noName", skill: skillA = "noSkill"  } of getRobots()) {
 >nameA : string
 }
 for ({name: nameA = "noName", skill: skillA = "noSkill"  } of [{ name: "mower", skill: "mowing" }, { name: "trimmer", skill: "trimming" }]) {
->{name: nameA = "noName", skill: skillA = "noSkill"  } : { name: string; skill: string; }
+>{name: nameA = "noName", skill: skillA = "noSkill"  } : { name?: string; skill?: string; }
 >name : { name: string; skill: string; }
 >nameA = "noName" : string
 >nameA : string
@@ -502,7 +502,7 @@ for ({name: nameA = "noName", skill: skillA = "noSkill"  } of [{ name: "mower",
 >nameA : string
 }
 for ({
->{    name: nameA = "noName",    skills: {        primary: primaryA = "primary",        secondary: secondaryA = "secondary"    } = { primary: "noSkill", secondary: "noSkill" }} : { name: string; skills: { primary?: string; secondary?: string; }; }
+>{    name: nameA = "noName",    skills: {        primary: primaryA = "primary",        secondary: secondaryA = "secondary"    } = { primary: "noSkill", secondary: "noSkill" }} : { name?: string; skills?: { primary?: string; secondary?: string; }; }
 
     name: nameA = "noName",
 >name : MultiRobot
@@ -545,7 +545,7 @@ for ({
 >nameA : string
 }
 for ({
->{    name: nameA = "noName",    skills: {        primary: primaryA = "primary",        secondary: secondaryA = "secondary"    } = { primary: "noSkill", secondary: "noSkill" }} : { name: string; skills: { primary?: string; secondary?: string; }; }
+>{    name: nameA = "noName",    skills: {        primary: primaryA = "primary",        secondary: secondaryA = "secondary"    } = { primary: "noSkill", secondary: "noSkill" }} : { name?: string; skills?: { primary?: string; secondary?: string; }; }
 
     name: nameA = "noName",
 >name : MultiRobot
@@ -589,7 +589,7 @@ for ({
 >nameA : string
 }
 for ({
->{    name: nameA = "noName",    skills: {        primary: primaryA = "primary",        secondary: secondaryA = "secondary"    } = { primary: "noSkill", secondary: "noSkill" }} : { name: string; skills: { primary?: string; secondary?: string; }; }
+>{    name: nameA = "noName",    skills: {        primary: primaryA = "primary",        secondary: secondaryA = "secondary"    } = { primary: "noSkill", secondary: "noSkill" }} : { name?: string; skills?: { primary?: string; secondary?: string; }; }
 
     name: nameA = "noName",
 >name : MultiRobot
@@ -655,7 +655,7 @@ for ({
 }
 
 for ({ name = "noName", skill  = "noSkill" } of robots) {
->{ name = "noName", skill  = "noSkill" } : { name: string; skill: string; }
+>{ name = "noName", skill  = "noSkill" } : { name?: string; skill?: string; }
 >name : Robot
 >skill : Robot
 >robots : Robot[]
@@ -668,7 +668,7 @@ for ({ name = "noName", skill  = "noSkill" } of robots) {
 >nameA : string
 }
 for ({ name = "noName", skill = "noSkill"  } of getRobots()) {
->{ name = "noName", skill = "noSkill"  } : { name: string; skill: string; }
+>{ name = "noName", skill = "noSkill"  } : { name?: string; skill?: string; }
 >name : Robot
 >skill : Robot
 >getRobots() : Robot[]
@@ -682,7 +682,7 @@ for ({ name = "noName", skill = "noSkill"  } of getRobots()) {
 >nameA : string
 }
 for ({ name = "noName", skill  = "noSkill" } of [{ name: "mower", skill: "mowing" }, { name: "trimmer", skill: "trimming" }]) {
->{ name = "noName", skill  = "noSkill" } : { name: string; skill: string; }
+>{ name = "noName", skill  = "noSkill" } : { name?: string; skill?: string; }
 >name : { name: string; skill: string; }
 >skill : { name: string; skill: string; }
 >[{ name: "mower", skill: "mowing" }, { name: "trimmer", skill: "trimming" }] : { name: string; skill: string; }[]
@@ -705,7 +705,7 @@ for ({ name = "noName", skill  = "noSkill" } of [{ name: "mower", skill: "mowing
 >nameA : string
 }
 for ({
->{    name = "noName",    skills: {        primary = "primary",        secondary = "secondary"    } = { primary: "noSkill", secondary: "noSkill" }} : { name: string; skills: { primary?: string; secondary?: string; }; }
+>{    name = "noName",    skills: {        primary = "primary",        secondary = "secondary"    } = { primary: "noSkill", secondary: "noSkill" }} : { name?: string; skills?: { primary?: string; secondary?: string; }; }
 
     name = "noName",
 >name : MultiRobot
@@ -739,7 +739,7 @@ for ({
 >nameA : string
 }
 for ({
->{    name = "noName",    skills: {        primary = "primary",        secondary = "secondary"    } = { primary: "noSkill", secondary: "noSkill" }} : { name: string; skills: { primary?: string; secondary?: string; }; }
+>{    name = "noName",    skills: {        primary = "primary",        secondary = "secondary"    } = { primary: "noSkill", secondary: "noSkill" }} : { name?: string; skills?: { primary?: string; secondary?: string; }; }
 
     name = "noName",
 >name : MultiRobot
@@ -774,7 +774,7 @@ for ({
 >nameA : string
 }
 for ({
->{    name = "noName",    skills: {        primary = "primary",        secondary = "secondary"    } = { primary: "noSkill", secondary: "noSkill" }} : { name: string; skills: { primary?: string; secondary?: string; }; }
+>{    name = "noName",    skills: {        primary = "primary",        secondary = "secondary"    } = { primary: "noSkill", secondary: "noSkill" }} : { name?: string; skills?: { primary?: string; secondary?: string; }; }
 
     name = "noName",
 >name : { name: string; skills: { primary: string; secondary: string; }; }

tests/baselines/reference/systemModule13.types

@@ -24,7 +24,7 @@ export const {a: z0, b: {c: z1}} = {a: true, b: {c: "123"}};
 >"123" : string
 
 for ([x] of [[1]]) {}
->[x] : number[]
+>[x] : [number]
 >x : number
 >[[1]] : number[][]
 >[1] : number[]

tests/baselines/reference/systemModule8.types

@@ -135,7 +135,7 @@ export const {a: z0, b: {c: z1}} = {a: true, b: {c: "123"}};
 >"123" : string
 
 for ([x] of [[1]]) {}
->[x] : any[]
+>[x] : [any]
 >x : any
 >[[1]] : number[][]
 >[1] : number[]