Update baselines from merging master

tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES5.js

@@ -85,16 +85,16 @@ function foo() {
     return [1, 2, 3];
 }
 var _e = foo(), b6 = _e[0], b7 = _e[1];
-var _f = foo(), b8 = _f.slice(0);
+var b8 = foo().slice(0);
 //      S is not a tuple- like type and the numeric index signature type of S is assignable to the target given in E.
 var temp = [1, 2, 3];
-var _g = temp, c0 = _g[0], c1 = _g[1];
-var c2 = ([])[0];
-var _h = [[[]], [[[[]]]]], c3 = _h[0][0][0], c4 = _h[1][0][0][0][0];
-var _j = [[1], true], c5 = _j[0][0], c6 = _j[1];
-var _k = [1, 2, 3], c7 = _k[1];
-var _l = [1, 2, 3, 4], c8 = _l[3];
-var _m = [1, 2, 3, 4], c9 = _m[3];
-var _o = [1, 2, 3, 4, "hello"], c10 = _o.slice(3);
-var _p = [1, 2, "string"], c11 = _p[0], c12 = _p[1], c13 = _p.slice(2);
-var _q = [1, 2, "string"], c14 = _q[0], c15 = _q[1], c16 = _q[2];
+var _f = temp, c0 = _f[0], c1 = _f[1];
+var c2 = [][0];
+var _g = [[[]], [[[[]]]]], c3 = _g[0][0][0], c4 = _g[1][0][0][0][0];
+var _h = [[1], true], c5 = _h[0][0], c6 = _h[1];
+var _j = [1, 2, 3], c7 = _j[1];
+var _k = [1, 2, 3, 4], c8 = _k[3];
+var _l = [1, 2, 3, 4], c9 = _l[3];
+var _m = [1, 2, 3, 4, "hello"], c10 = _m.slice(3);
+var _o = [1, 2, "string"], c11 = _o[0], c12 = _o[1], c13 = _o.slice(2);
+var _p = [1, 2, "string"], c14 = _p[0], c15 = _p[1], c16 = _p[2];

tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES5.symbols

@@ -0,0 +1,105 @@
+=== tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment1ES5.ts ===
+/* AssignmentPattern:
+ *      ObjectAssignmentPattern
+ *      ArrayAssignmentPattern
+ * ArrayAssignmentPattern:
+ *      [Elision<opt>   AssignmentRestElementopt   ]
+ *      [AssignmentElementList]
+ *      [AssignmentElementList, Elision<opt>   AssignmentRestElementopt   ]
+ * AssignmentElementList:
+ *      Elision<opt>   AssignmentElement
+ *      AssignmentElementList, Elisionopt   AssignmentElement
+ * AssignmentElement:
+ *      LeftHandSideExpression   Initialiseropt
+ *      AssignmentPattern   Initialiseropt
+ * AssignmentRestElement:
+ *      ...   LeftHandSideExpression
+ */
+
+// In a destructuring assignment expression, the type of the expression on the right must be assignable to the assignment target on the left.
+// An expression of type S is considered assignable to an assignment target V if one of the following is true
+
+// V is an array assignment pattern, S is the type Any or an array-like type (section 3.3.2), and, for each assignment element E in V,
+//      S is the type Any, or
+
+var [a0, a1]: any = undefined;
+>a0 : Symbol(a0, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 23, 5))
+>a1 : Symbol(a1, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 23, 8))
+>undefined : Symbol(undefined)
+
+var [a2 = false, a3 = 1]: any = undefined;
+>a2 : Symbol(a2, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 24, 5))
+>a3 : Symbol(a3, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 24, 16))
+>undefined : Symbol(undefined)
+
+// V is an array assignment pattern, S is the type Any or an array-like type (section 3.3.2), and, for each assignment element E in V,
+//      S is a tuple- like type (section 3.3.3) with a property named N of a type that is assignable to the target given in E,
+//        where N is the numeric index of E in the array assignment pattern, or
+var [b0, b1, b2] = [2, 3, 4];
+>b0 : Symbol(b0, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 29, 5))
+>b1 : Symbol(b1, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 29, 8))
+>b2 : Symbol(b2, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 29, 12))
+
+var [b3, b4, b5]: [number, number, string] = [1, 2, "string"];
+>b3 : Symbol(b3, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 30, 5))
+>b4 : Symbol(b4, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 30, 8))
+>b5 : Symbol(b5, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 30, 12))
+
+function foo() {
+>foo : Symbol(foo, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 30, 62))
+
+    return [1, 2, 3];
+}
+
+var [b6, b7] = foo();
+>b6 : Symbol(b6, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 36, 5))
+>b7 : Symbol(b7, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 36, 8))
+>foo : Symbol(foo, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 30, 62))
+
+var [...b8] = foo();
+>b8 : Symbol(b8, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 37, 5))
+>foo : Symbol(foo, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 30, 62))
+
+//      S is not a tuple- like type and the numeric index signature type of S is assignable to the target given in E.
+var temp = [1,2,3]
+>temp : Symbol(temp, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 40, 3))
+
+var [c0, c1] = [...temp];
+>c0 : Symbol(c0, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 41, 5))
+>c1 : Symbol(c1, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 41, 8))
+>temp : Symbol(temp, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 40, 3))
+
+var [c2] = [];
+>c2 : Symbol(c2, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 42, 5))
+
+var [[[c3]], [[[[c4]]]]] = [[[]], [[[[]]]]]
+>c3 : Symbol(c3, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 43, 7))
+>c4 : Symbol(c4, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 43, 17))
+
+var [[c5], c6]: [[string|number], boolean] = [[1], true];
+>c5 : Symbol(c5, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 44, 6))
+>c6 : Symbol(c6, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 44, 10))
+
+var [, c7] = [1, 2, 3];
+>c7 : Symbol(c7, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 45, 6))
+
+var [,,, c8] = [1, 2, 3, 4];
+>c8 : Symbol(c8, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 46, 8))
+
+var [,,, c9] = [1, 2, 3, 4];
+>c9 : Symbol(c9, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 47, 8))
+
+var [,,,...c10] = [1, 2, 3, 4, "hello"];
+>c10 : Symbol(c10, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 48, 8))
+
+var [c11, c12, ...c13] = [1, 2, "string"];
+>c11 : Symbol(c11, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 49, 5))
+>c12 : Symbol(c12, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 49, 9))
+>c13 : Symbol(c13, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 49, 14))
+
+var [c14, c15, c16] = [1, 2, "string"];
+>c14 : Symbol(c14, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 50, 5))
+>c15 : Symbol(c15, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 50, 9))
+>c16 : Symbol(c16, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 50, 14))
+
+

tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES5.types

@@ -23,40 +23,40 @@
 //      S is the type Any, or
 
 var [a0, a1]: any = undefined;
->a0 : any, Symbol(a0, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 23, 5))
->a1 : any, Symbol(a1, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 23, 8))
->undefined : undefined, Symbol(undefined)
+>a0 : any
+>a1 : any
+>undefined : undefined
 
 var [a2 = false, a3 = 1]: any = undefined;
->a2 : boolean, Symbol(a2, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 24, 5))
+>a2 : boolean
 >false : boolean
->a3 : number, Symbol(a3, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 24, 16))
+>a3 : number
 >1 : number
->undefined : undefined, Symbol(undefined)
+>undefined : undefined
 
 // V is an array assignment pattern, S is the type Any or an array-like type (section 3.3.2), and, for each assignment element E in V,
 //      S is a tuple- like type (section 3.3.3) with a property named N of a type that is assignable to the target given in E,
 //        where N is the numeric index of E in the array assignment pattern, or
 var [b0, b1, b2] = [2, 3, 4];
->b0 : number, Symbol(b0, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 29, 5))
->b1 : number, Symbol(b1, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 29, 8))
->b2 : number, Symbol(b2, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 29, 12))
+>b0 : number
+>b1 : number
+>b2 : number
 >[2, 3, 4] : [number, number, number]
 >2 : number
 >3 : number
 >4 : number
 
 var [b3, b4, b5]: [number, number, string] = [1, 2, "string"];
->b3 : number, Symbol(b3, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 30, 5))
->b4 : number, Symbol(b4, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 30, 8))
->b5 : string, Symbol(b5, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 30, 12))
+>b3 : number
+>b4 : number
+>b5 : string
 >[1, 2, "string"] : [number, number, string]
 >1 : number
 >2 : number
 >"string" : string
 
 function foo() {
->foo : () => number[], Symbol(foo, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 30, 62))
+>foo : () => number[]
 
     return [1, 2, 3];
 >[1, 2, 3] : number[]
@@ -66,38 +66,38 @@ function foo() {
 }
 
 var [b6, b7] = foo();
->b6 : number, Symbol(b6, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 36, 5))
->b7 : number, Symbol(b7, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 36, 8))
+>b6 : number
+>b7 : number
 >foo() : number[]
->foo : () => number[], Symbol(foo, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 30, 62))
+>foo : () => number[]
 
 var [...b8] = foo();
->b8 : number[], Symbol(b8, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 37, 5))
+>b8 : number[]
 >foo() : number[]
->foo : () => number[], Symbol(foo, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 30, 62))
+>foo : () => number[]
 
 //      S is not a tuple- like type and the numeric index signature type of S is assignable to the target given in E.
 var temp = [1,2,3]
->temp : number[], Symbol(temp, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 40, 3))
+>temp : number[]
 >[1,2,3] : number[]
 >1 : number
 >2 : number
 >3 : number
 
 var [c0, c1] = [...temp];
->c0 : number, Symbol(c0, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 41, 5))
->c1 : number, Symbol(c1, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 41, 8))
+>c0 : number
+>c1 : number
 >[...temp] : number[]
 >...temp : number
->temp : number[], Symbol(temp, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 40, 3))
+>temp : number[]
 
 var [c2] = [];
->c2 : any, Symbol(c2, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 42, 5))
+>c2 : any
 >[] : undefined[]
 
 var [[[c3]], [[[[c4]]]]] = [[[]], [[[[]]]]]
->c3 : any, Symbol(c3, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 43, 7))
->c4 : any, Symbol(c4, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 43, 17))
+>c3 : any
+>c4 : any
 >[[[]], [[[[]]]]] : [[undefined[]], [[[undefined[]]]]]
 >[[]] : [undefined[]]
 >[] : undefined[]
@@ -107,8 +107,8 @@ var [[[c3]], [[[[c4]]]]] = [[[]], [[[[]]]]]
 >[] : undefined[]
 
 var [[c5], c6]: [[string|number], boolean] = [[1], true];
->c5 : string | number, Symbol(c5, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 44, 6))
->c6 : boolean, Symbol(c6, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 44, 10))
+>c5 : string | number
+>c6 : boolean
 >[[1], true] : [[number], boolean]
 >[1] : [number]
 >1 : number
@@ -116,7 +116,7 @@ var [[c5], c6]: [[string|number], boolean] = [[1], true];
 
 var [, c7] = [1, 2, 3];
 > : undefined
->c7 : number, Symbol(c7, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 45, 6))
+>c7 : number
 >[1, 2, 3] : [number, number, number]
 >1 : number
 >2 : number
@@ -126,7 +126,7 @@ var [,,, c8] = [1, 2, 3, 4];
 > : undefined
 > : undefined
 > : undefined
->c8 : number, Symbol(c8, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 46, 8))
+>c8 : number
 >[1, 2, 3, 4] : [number, number, number, number]
 >1 : number
 >2 : number
@@ -137,7 +137,7 @@ var [,,, c9] = [1, 2, 3, 4];
 > : undefined
 > : undefined
 > : undefined
->c9 : number, Symbol(c9, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 47, 8))
+>c9 : number
 >[1, 2, 3, 4] : [number, number, number, number]
 >1 : number
 >2 : number
@@ -148,7 +148,7 @@ var [,,,...c10] = [1, 2, 3, 4, "hello"];
 > : undefined
 > : undefined
 > : undefined
->c10 : (string | number)[], Symbol(c10, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 48, 8))
+>c10 : (string | number)[]
 >[1, 2, 3, 4, "hello"] : (string | number)[]
 >1 : number
 >2 : number
@@ -157,18 +157,18 @@ var [,,,...c10] = [1, 2, 3, 4, "hello"];
 >"hello" : string
 
 var [c11, c12, ...c13] = [1, 2, "string"];
->c11 : string | number, Symbol(c11, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 49, 5))
->c12 : string | number, Symbol(c12, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 49, 9))
->c13 : (string | number)[], Symbol(c13, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 49, 14))
+>c11 : string | number
+>c12 : string | number
+>c13 : (string | number)[]
 >[1, 2, "string"] : (string | number)[]
 >1 : number
 >2 : number
 >"string" : string
 
 var [c14, c15, c16] = [1, 2, "string"];
->c14 : number, Symbol(c14, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 50, 5))
->c15 : number, Symbol(c15, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 50, 9))
->c16 : string, Symbol(c16, Decl(destructuringArrayBindingPatternAndAssignment1ES5.ts, 50, 14))
+>c14 : number
+>c15 : number
+>c16 : string
 >[1, 2, "string"] : [number, number, string]
 >1 : number
 >2 : number

tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES6.symbols

@@ -0,0 +1,105 @@
+=== tests/cases/conformance/es6/destructuring/destructuringArrayBindingPatternAndAssignment1ES6.ts ===
+
+/* AssignmentPattern:
+ *      ObjectAssignmentPattern
+ *      ArrayAssignmentPattern
+ * ArrayAssignmentPattern:
+ *      [Elision<opt>   AssignmentRestElementopt   ]
+ *      [AssignmentElementList]
+ *      [AssignmentElementList, Elision<opt>   AssignmentRestElementopt   ]
+ * AssignmentElementList:
+ *      Elision<opt>   AssignmentElement
+ *      AssignmentElementList, Elisionopt   AssignmentElement
+ * AssignmentElement:
+ *      LeftHandSideExpression   Initialiseropt
+ *      AssignmentPattern   Initialiseropt
+ * AssignmentRestElement:
+ *      ...   LeftHandSideExpression
+ */
+
+// In a destructuring assignment expression, the type of the expression on the right must be assignable to the assignment target on the left.
+// An expression of type S is considered assignable to an assignment target V if one of the following is true
+
+// V is an array assignment pattern, S is the type Any or an array-like type (section 3.3.2), and, for each assignment element E in V,
+//      S is the type Any, or
+
+var [a0, a1]: any = undefined;
+>a0 : Symbol(a0, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 24, 5))
+>a1 : Symbol(a1, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 24, 8))
+>undefined : Symbol(undefined)
+
+var [a2 = false, a3 = 1]: any = undefined;
+>a2 : Symbol(a2, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 25, 5))
+>a3 : Symbol(a3, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 25, 16))
+>undefined : Symbol(undefined)
+
+// V is an array assignment pattern, S is the type Any or an array-like type (section 3.3.2), and, for each assignment element E in V,
+//      S is a tuple- like type (section 3.3.3) with a property named N of a type that is assignable to the target given in E,
+//        where N is the numeric index of E in the array assignment pattern, or
+var [b0, b1, b2] = [2, 3, 4];
+>b0 : Symbol(b0, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 30, 5))
+>b1 : Symbol(b1, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 30, 8))
+>b2 : Symbol(b2, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 30, 12))
+
+var [b3, b4, b5]: [number, number, string] = [1, 2, "string"];
+>b3 : Symbol(b3, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 31, 5))
+>b4 : Symbol(b4, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 31, 8))
+>b5 : Symbol(b5, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 31, 12))
+
+function foo() {
+>foo : Symbol(foo, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 31, 62))
+
+    return [1, 2, 3];
+}
+
+var [b6, b7] = foo();
+>b6 : Symbol(b6, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 37, 5))
+>b7 : Symbol(b7, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 37, 8))
+>foo : Symbol(foo, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 31, 62))
+
+var [...b8] = foo();
+>b8 : Symbol(b8, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 38, 5))
+>foo : Symbol(foo, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 31, 62))
+
+//      S is not a tuple- like type and the numeric index signature type of S is assignable to the target given in E.
+var temp = [1,2,3]
+>temp : Symbol(temp, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 41, 3))
+
+var [c0, c1] = [...temp];
+>c0 : Symbol(c0, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 42, 5))
+>c1 : Symbol(c1, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 42, 8))
+>temp : Symbol(temp, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 41, 3))
+
+var [c2] = [];
+>c2 : Symbol(c2, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 43, 5))
+
+var [[[c3]], [[[[c4]]]]] = [[[]], [[[[]]]]]
+>c3 : Symbol(c3, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 44, 7))
+>c4 : Symbol(c4, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 44, 17))
+
+var [[c5], c6]: [[string|number], boolean] = [[1], true];
+>c5 : Symbol(c5, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 45, 6))
+>c6 : Symbol(c6, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 45, 10))
+
+var [, c7] = [1, 2, 3];
+>c7 : Symbol(c7, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 46, 6))
+
+var [,,, c8] = [1, 2, 3, 4];
+>c8 : Symbol(c8, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 47, 8))
+
+var [,,, c9] = [1, 2, 3, 4];
+>c9 : Symbol(c9, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 48, 8))
+
+var [,,,...c10] = [1, 2, 3, 4, "hello"];
+>c10 : Symbol(c10, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 49, 8))
+
+var [c11, c12, ...c13] = [1, 2, "string"];
+>c11 : Symbol(c11, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 50, 5))
+>c12 : Symbol(c12, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 50, 9))
+>c13 : Symbol(c13, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 50, 14))
+
+var [c14, c15, c16] = [1, 2, "string"];
+>c14 : Symbol(c14, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 51, 5))
+>c15 : Symbol(c15, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 51, 9))
+>c16 : Symbol(c16, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 51, 14))
+

tests/baselines/reference/destructuringArrayBindingPatternAndAssignment1ES6.types

@@ -24,40 +24,40 @@
 //      S is the type Any, or
 
 var [a0, a1]: any = undefined;
->a0 : any, Symbol(a0, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 24, 5))
->a1 : any, Symbol(a1, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 24, 8))
->undefined : undefined, Symbol(undefined)
+>a0 : any
+>a1 : any
+>undefined : undefined
 
 var [a2 = false, a3 = 1]: any = undefined;
->a2 : boolean, Symbol(a2, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 25, 5))
+>a2 : boolean
 >false : boolean
->a3 : number, Symbol(a3, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 25, 16))
+>a3 : number
 >1 : number
->undefined : undefined, Symbol(undefined)
+>undefined : undefined
 
 // V is an array assignment pattern, S is the type Any or an array-like type (section 3.3.2), and, for each assignment element E in V,
 //      S is a tuple- like type (section 3.3.3) with a property named N of a type that is assignable to the target given in E,
 //        where N is the numeric index of E in the array assignment pattern, or
 var [b0, b1, b2] = [2, 3, 4];
->b0 : number, Symbol(b0, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 30, 5))
->b1 : number, Symbol(b1, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 30, 8))
->b2 : number, Symbol(b2, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 30, 12))
+>b0 : number
+>b1 : number
+>b2 : number
 >[2, 3, 4] : [number, number, number]
 >2 : number
 >3 : number
 >4 : number
 
 var [b3, b4, b5]: [number, number, string] = [1, 2, "string"];
->b3 : number, Symbol(b3, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 31, 5))
->b4 : number, Symbol(b4, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 31, 8))
->b5 : string, Symbol(b5, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 31, 12))
+>b3 : number
+>b4 : number
+>b5 : string
 >[1, 2, "string"] : [number, number, string]
 >1 : number
 >2 : number
 >"string" : string
 
 function foo() {
->foo : () => number[], Symbol(foo, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 31, 62))
+>foo : () => number[]
 
     return [1, 2, 3];
 >[1, 2, 3] : number[]
@@ -67,38 +67,38 @@ function foo() {
 }
 
 var [b6, b7] = foo();
->b6 : number, Symbol(b6, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 37, 5))
->b7 : number, Symbol(b7, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 37, 8))
+>b6 : number
+>b7 : number
 >foo() : number[]
->foo : () => number[], Symbol(foo, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 31, 62))
+>foo : () => number[]
 
 var [...b8] = foo();
->b8 : number[], Symbol(b8, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 38, 5))
+>b8 : number[]
 >foo() : number[]
->foo : () => number[], Symbol(foo, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 31, 62))
+>foo : () => number[]
 
 //      S is not a tuple- like type and the numeric index signature type of S is assignable to the target given in E.
 var temp = [1,2,3]
->temp : number[], Symbol(temp, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 41, 3))
+>temp : number[]
 >[1,2,3] : number[]
 >1 : number
 >2 : number
 >3 : number
 
 var [c0, c1] = [...temp];
->c0 : number, Symbol(c0, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 42, 5))
->c1 : number, Symbol(c1, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 42, 8))
+>c0 : number
+>c1 : number
 >[...temp] : number[]
 >...temp : number
->temp : number[], Symbol(temp, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 41, 3))
+>temp : number[]
 
 var [c2] = [];
->c2 : any, Symbol(c2, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 43, 5))
+>c2 : any
 >[] : undefined[]
 
 var [[[c3]], [[[[c4]]]]] = [[[]], [[[[]]]]]
->c3 : any, Symbol(c3, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 44, 7))
->c4 : any, Symbol(c4, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 44, 17))
+>c3 : any
+>c4 : any
 >[[[]], [[[[]]]]] : [[undefined[]], [[[undefined[]]]]]
 >[[]] : [undefined[]]
 >[] : undefined[]
@@ -108,8 +108,8 @@ var [[[c3]], [[[[c4]]]]] = [[[]], [[[[]]]]]
 >[] : undefined[]
 
 var [[c5], c6]: [[string|number], boolean] = [[1], true];
->c5 : string | number, Symbol(c5, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 45, 6))
->c6 : boolean, Symbol(c6, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 45, 10))
+>c5 : string | number
+>c6 : boolean
 >[[1], true] : [[number], boolean]
 >[1] : [number]
 >1 : number
@@ -117,7 +117,7 @@ var [[c5], c6]: [[string|number], boolean] = [[1], true];
 
 var [, c7] = [1, 2, 3];
 > : undefined
->c7 : number, Symbol(c7, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 46, 6))
+>c7 : number
 >[1, 2, 3] : [number, number, number]
 >1 : number
 >2 : number
@@ -127,7 +127,7 @@ var [,,, c8] = [1, 2, 3, 4];
 > : undefined
 > : undefined
 > : undefined
->c8 : number, Symbol(c8, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 47, 8))
+>c8 : number
 >[1, 2, 3, 4] : [number, number, number, number]
 >1 : number
 >2 : number
@@ -138,7 +138,7 @@ var [,,, c9] = [1, 2, 3, 4];
 > : undefined
 > : undefined
 > : undefined
->c9 : number, Symbol(c9, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 48, 8))
+>c9 : number
 >[1, 2, 3, 4] : [number, number, number, number]
 >1 : number
 >2 : number
@@ -149,7 +149,7 @@ var [,,,...c10] = [1, 2, 3, 4, "hello"];
 > : undefined
 > : undefined
 > : undefined
->c10 : (string | number)[], Symbol(c10, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 49, 8))
+>c10 : (string | number)[]
 >[1, 2, 3, 4, "hello"] : (string | number)[]
 >1 : number
 >2 : number
@@ -158,18 +158,18 @@ var [,,,...c10] = [1, 2, 3, 4, "hello"];
 >"hello" : string
 
 var [c11, c12, ...c13] = [1, 2, "string"];
->c11 : string | number, Symbol(c11, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 50, 5))
->c12 : string | number, Symbol(c12, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 50, 9))
->c13 : (string | number)[], Symbol(c13, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 50, 14))
+>c11 : string | number
+>c12 : string | number
+>c13 : (string | number)[]
 >[1, 2, "string"] : (string | number)[]
 >1 : number
 >2 : number
 >"string" : string
 
 var [c14, c15, c16] = [1, 2, "string"];
->c14 : number, Symbol(c14, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 51, 5))
->c15 : number, Symbol(c15, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 51, 9))
->c16 : string, Symbol(c16, Decl(destructuringArrayBindingPatternAndAssignment1ES6.ts, 51, 14))
+>c14 : number
+>c15 : number
+>c16 : string
 >[1, 2, "string"] : [number, number, string]
 >1 : number
 >2 : number

tests/baselines/reference/destructuringObjectBindingPatternAndAssignment1ES5.js

@@ -60,15 +60,15 @@ var {"prop2": d1} = foo1();
 // V is an object assignment pattern and, for each assignment property P in V,
 //      S is the type Any, or
 var a1 = undefined.a1;
-var a2 = ({}).a2;
+var a2 = {}.a2;
 // V is an object assignment pattern and, for each assignment property P in V,
 //      S has an apparent property with the property name specified in
 //          P of a type that is assignable to the target given in P, or
-var b1 = ({ b1: 1 }).b1;
-var _a = ({ b2: { b21: "world" } }).b2, b21 = (_a === void 0 ? { b21: "string" } : _a).b21;
-var b3 = ({ 1: "string" })[1];
-var _b = ({ b4: 100000 }).b4, b4 = _b === void 0 ? 1 : _b;
-var b52 = ({ b5: { b52: b52 } }).b5.b52;
+var b1 = { b1: 1 }.b1;
+var _a = { b2: { b21: "world" } }.b2, b21 = (_a === void 0 ? { b21: "string" } : _a).b21;
+var b3 = { 1: "string" }[1];
+var _b = { b4: 100000 }.b4, b4 = _b === void 0 ? 1 : _b;
+var b52 = { b5: { b52: b52 } }.b5.b52;
 function foo() {
     return {
         1: true
@@ -79,12 +79,12 @@ function bar() {
         2: true
     };
 }
-var c0 = (foo())[1];
-var c1 = (bar())[1];
+var c0 = foo()[1];
+var c1 = bar()[1];
 function foo1() {
     return {
         "prop1": 2
     };
 }
-var d1 = (foo1())["prop1"];
-var d1 = (foo1())["prop2"];
+var d1 = foo1()["prop1"];
+var d1 = foo1()["prop2"];

tests/baselines/reference/destructuringObjectBindingPatternAndAssignment1ES5.symbols

@@ -0,0 +1,101 @@
+=== tests/cases/conformance/es6/destructuring/destructuringObjectBindingPatternAndAssignment1ES5.ts ===
+// In a destructuring assignment expression, the type of the expression on the right must be assignable to the assignment target on the left.
+// An expression of type S is considered assignable to an assignment target V if one of the following is true
+
+// V is an object assignment pattern and, for each assignment property P in V,
+//      S is the type Any, or
+var { a1 }: any = undefined;
+>a1 : Symbol(a1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 5, 5))
+>undefined : Symbol(undefined)
+
+var { a2 }: any = {};
+>a2 : Symbol(a2, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 6, 5))
+
+// V is an object assignment pattern and, for each assignment property P in V,
+//      S has an apparent property with the property name specified in
+//          P of a type that is assignable to the target given in P, or
+var { b1, } = { b1:1, };
+>b1 : Symbol(b1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 11, 5))
+>b1 : Symbol(b1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 11, 15))
+
+var { b2: { b21 } = { b21: "string" }  } = { b2: { b21: "world" } };
+>b21 : Symbol(b21, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 12, 11))
+>b21 : Symbol(b21, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 12, 21))
+>b2 : Symbol(b2, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 12, 44))
+>b21 : Symbol(b21, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 12, 50))
+
+var {1: b3} = { 1: "string" };
+>b3 : Symbol(b3, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 13, 5))
+
+var {b4 = 1}: any = { b4: 100000 };
+>b4 : Symbol(b4, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 14, 5))
+>b4 : Symbol(b4, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 14, 21))
+
+var {b5: { b52 }  } = { b5: { b52 } };
+>b52 : Symbol(b52, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 15, 10))
+>b5 : Symbol(b5, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 15, 23))
+>b52 : Symbol(b52, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 15, 29))
+
+// V is an object assignment pattern and, for each assignment property P in V,
+//      P specifies a numeric property name and S has a numeric index signature
+//          of a type that is assignable to the target given in P, or
+
+interface F {
+>F : Symbol(F, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 15, 38))
+
+    [idx: number]: boolean;
+>idx : Symbol(idx, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 22, 5))
+}
+
+function foo(): F {
+>foo : Symbol(foo, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 23, 1))
+>F : Symbol(F, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 15, 38))
+
+    return {
+        1: true
+    };
+}
+
+function bar(): F {
+>bar : Symbol(bar, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 29, 1))
+>F : Symbol(F, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 15, 38))
+
+    return {
+        2: true
+    };
+}
+var {1: c0} = foo();
+>c0 : Symbol(c0, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 36, 5))
+>foo : Symbol(foo, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 23, 1))
+
+var {1: c1} = bar();
+>c1 : Symbol(c1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 37, 5))
+>bar : Symbol(bar, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 29, 1))
+
+// V is an object assignment pattern and, for each assignment property P in V,
+//      S has a string index signature of a type that is assignable to the target given in P
+
+interface F1 {
+>F1 : Symbol(F1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 37, 20))
+
+    [str: string]: number;
+>str : Symbol(str, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 43, 5))
+}
+
+function foo1(): F1 {
+>foo1 : Symbol(foo1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 44, 1))
+>F1 : Symbol(F1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 37, 20))
+
+    return {
+        "prop1": 2
+    }
+}
+
+var {"prop1": d1} = foo1();
+>d1 : Symbol(d1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 52, 5), Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 53, 5))
+>foo1 : Symbol(foo1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 44, 1))
+
+var {"prop2": d1} = foo1();
+>d1 : Symbol(d1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 52, 5), Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 53, 5))
+>foo1 : Symbol(foo1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 44, 1))
+

tests/baselines/reference/destructuringObjectBindingPatternAndAssignment1ES5.types

@@ -5,68 +5,68 @@
 // V is an object assignment pattern and, for each assignment property P in V,
 //      S is the type Any, or
 var { a1 }: any = undefined;
->a1 : any, Symbol(a1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 5, 5))
->undefined : undefined, Symbol(undefined)
+>a1 : any
+>undefined : undefined
 
 var { a2 }: any = {};
->a2 : any, Symbol(a2, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 6, 5))
+>a2 : any
 >{} : {}
 
 // V is an object assignment pattern and, for each assignment property P in V,
 //      S has an apparent property with the property name specified in
 //          P of a type that is assignable to the target given in P, or
 var { b1, } = { b1:1, };
->b1 : number, Symbol(b1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 11, 5))
+>b1 : number
 >{ b1:1, } : { b1: number; }
->b1 : number, Symbol(b1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 11, 15))
+>b1 : number
 >1 : number
 
 var { b2: { b21 } = { b21: "string" }  } = { b2: { b21: "world" } };
 >b2 : any
->b21 : string, Symbol(b21, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 12, 11))
+>b21 : string
 >{ b21: "string" } : { b21: string; }
->b21 : string, Symbol(b21, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 12, 21))
+>b21 : string
 >"string" : string
 >{ b2: { b21: "world" } } : { b2: { b21: string; }; }
->b2 : { b21: string; }, Symbol(b2, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 12, 44))
+>b2 : { b21: string; }
 >{ b21: "world" } : { b21: string; }
->b21 : string, Symbol(b21, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 12, 50))
+>b21 : string
 >"world" : string
 
 var {1: b3} = { 1: "string" };
->b3 : string, Symbol(b3, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 13, 5))
+>b3 : string
 >{ 1: "string" } : { 1: string; }
 >"string" : string
 
 var {b4 = 1}: any = { b4: 100000 };
->b4 : number, Symbol(b4, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 14, 5))
+>b4 : number
 >1 : number
 >{ b4: 100000 } : { b4: number; }
->b4 : number, Symbol(b4, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 14, 21))
+>b4 : number
 >100000 : number
 
 var {b5: { b52 }  } = { b5: { b52 } };
 >b5 : any
->b52 : any, Symbol(b52, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 15, 10))
+>b52 : any
 >{ b5: { b52 } } : { b5: { b52: any; }; }
->b5 : { b52: any; }, Symbol(b5, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 15, 23))
+>b5 : { b52: any; }
 >{ b52 } : { b52: any; }
->b52 : any, Symbol(b52, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 15, 29))
+>b52 : any
 
 // V is an object assignment pattern and, for each assignment property P in V,
 //      P specifies a numeric property name and S has a numeric index signature
 //          of a type that is assignable to the target given in P, or
 
 interface F {
->F : F, Symbol(F, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 15, 38))
+>F : F
 
     [idx: number]: boolean;
->idx : number, Symbol(idx, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 22, 5))
+>idx : number
 }
 
 function foo(): F {
->foo : () => F, Symbol(foo, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 23, 1))
->F : F, Symbol(F, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 15, 38))
+>foo : () => F
+>F : F
 
     return {
 >{        1: true    } : { [x: number]: boolean; 1: boolean; }
@@ -78,8 +78,8 @@ function foo(): F {
 }
 
 function bar(): F {
->bar : () => F, Symbol(bar, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 29, 1))
->F : F, Symbol(F, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 15, 38))
+>bar : () => F
+>F : F
 
     return {
 >{        2: true    } : { [x: number]: boolean; 2: boolean; }
@@ -90,28 +90,28 @@ function bar(): F {
     };
 }
 var {1: c0} = foo();
->c0 : boolean, Symbol(c0, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 36, 5))
+>c0 : boolean
 >foo() : F
->foo : () => F, Symbol(foo, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 23, 1))
+>foo : () => F
 
 var {1: c1} = bar();
->c1 : boolean, Symbol(c1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 37, 5))
+>c1 : boolean
 >bar() : F
->bar : () => F, Symbol(bar, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 29, 1))
+>bar : () => F
 
 // V is an object assignment pattern and, for each assignment property P in V,
 //      S has a string index signature of a type that is assignable to the target given in P
 
 interface F1 {
->F1 : F1, Symbol(F1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 37, 20))
+>F1 : F1
 
     [str: string]: number;
->str : string, Symbol(str, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 43, 5))
+>str : string
 }
 
 function foo1(): F1 {
->foo1 : () => F1, Symbol(foo1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 44, 1))
->F1 : F1, Symbol(F1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 37, 20))
+>foo1 : () => F1
+>F1 : F1
 
     return {
 >{        "prop1": 2    } : { [x: string]: number; "prop1": number; }
@@ -122,12 +122,12 @@ function foo1(): F1 {
 }
 
 var {"prop1": d1} = foo1();
->d1 : number, Symbol(d1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 52, 5), Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 53, 5))
+>d1 : number
 >foo1() : F1
->foo1 : () => F1, Symbol(foo1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 44, 1))
+>foo1 : () => F1
 
 var {"prop2": d1} = foo1();
->d1 : number, Symbol(d1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 52, 5), Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 53, 5))
+>d1 : number
 >foo1() : F1
->foo1 : () => F1, Symbol(foo1, Decl(destructuringObjectBindingPatternAndAssignment1ES5.ts, 44, 1))
+>foo1 : () => F1
 

tests/baselines/reference/destructuringObjectBindingPatternAndAssignment1ES6.symbols

@@ -0,0 +1,101 @@
+=== tests/cases/conformance/es6/destructuring/destructuringObjectBindingPatternAndAssignment1ES6.ts ===
+// In a destructuring assignment expression, the type of the expression on the right must be assignable to the assignment target on the left.
+// An expression of type S is considered assignable to an assignment target V if one of the following is true
+
+// V is an object assignment pattern and, for each assignment property P in V,
+//      S is the type Any, or
+var { a1 }: any = undefined;
+>a1 : Symbol(a1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 5, 5))
+>undefined : Symbol(undefined)
+
+var { a2 }: any = {};
+>a2 : Symbol(a2, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 6, 5))
+
+// V is an object assignment pattern and, for each assignment property P in V,
+//      S has an apparent property with the property name specified in
+//          P of a type that is assignable to the target given in P, or
+var { b1, } = { b1:1, };
+>b1 : Symbol(b1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 11, 5))
+>b1 : Symbol(b1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 11, 15))
+
+var { b2: { b21 } = { b21: "string" }  } = { b2: { b21: "world" } };
+>b21 : Symbol(b21, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 12, 11))
+>b21 : Symbol(b21, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 12, 21))
+>b2 : Symbol(b2, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 12, 44))
+>b21 : Symbol(b21, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 12, 50))
+
+var {1: b3} = { 1: "string" };
+>b3 : Symbol(b3, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 13, 5))
+
+var {b4 = 1}: any = { b4: 100000 };
+>b4 : Symbol(b4, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 14, 5))
+>b4 : Symbol(b4, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 14, 21))
+
+var {b5: { b52 }  } = { b5: { b52 } };
+>b52 : Symbol(b52, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 15, 10))
+>b5 : Symbol(b5, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 15, 23))
+>b52 : Symbol(b52, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 15, 29))
+
+// V is an object assignment pattern and, for each assignment property P in V,
+//      P specifies a numeric property name and S has a numeric index signature
+//          of a type that is assignable to the target given in P, or
+
+interface F {
+>F : Symbol(F, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 15, 38))
+
+    [idx: number]: boolean;
+>idx : Symbol(idx, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 22, 5))
+}
+
+function foo(): F {
+>foo : Symbol(foo, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 23, 1))
+>F : Symbol(F, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 15, 38))
+
+    return {
+        1: true
+    };
+}
+
+function bar(): F {
+>bar : Symbol(bar, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 29, 1))
+>F : Symbol(F, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 15, 38))
+
+    return {
+        2: true
+    };
+}
+var {1: c0} = foo();
+>c0 : Symbol(c0, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 36, 5))
+>foo : Symbol(foo, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 23, 1))
+
+var {1: c1} = bar();
+>c1 : Symbol(c1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 37, 5))
+>bar : Symbol(bar, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 29, 1))
+
+// V is an object assignment pattern and, for each assignment property P in V,
+//      S has a string index signature of a type that is assignable to the target given in P
+
+interface F1 {
+>F1 : Symbol(F1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 37, 20))
+
+    [str: string]: number;
+>str : Symbol(str, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 43, 5))
+}
+
+function foo1(): F1 {
+>foo1 : Symbol(foo1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 44, 1))
+>F1 : Symbol(F1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 37, 20))
+
+    return {
+        "prop1": 2
+    }
+}
+
+var {"prop1": d1} = foo1();
+>d1 : Symbol(d1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 52, 5), Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 53, 5))
+>foo1 : Symbol(foo1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 44, 1))
+
+var {"prop2": d1} = foo1();
+>d1 : Symbol(d1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 52, 5), Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 53, 5))
+>foo1 : Symbol(foo1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 44, 1))
+

tests/baselines/reference/destructuringObjectBindingPatternAndAssignment1ES6.types

@@ -5,68 +5,68 @@
 // V is an object assignment pattern and, for each assignment property P in V,
 //      S is the type Any, or
 var { a1 }: any = undefined;
->a1 : any, Symbol(a1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 5, 5))
->undefined : undefined, Symbol(undefined)
+>a1 : any
+>undefined : undefined
 
 var { a2 }: any = {};
->a2 : any, Symbol(a2, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 6, 5))
+>a2 : any
 >{} : {}
 
 // V is an object assignment pattern and, for each assignment property P in V,
 //      S has an apparent property with the property name specified in
 //          P of a type that is assignable to the target given in P, or
 var { b1, } = { b1:1, };
->b1 : number, Symbol(b1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 11, 5))
+>b1 : number
 >{ b1:1, } : { b1: number; }
->b1 : number, Symbol(b1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 11, 15))
+>b1 : number
 >1 : number
 
 var { b2: { b21 } = { b21: "string" }  } = { b2: { b21: "world" } };
 >b2 : any
->b21 : string, Symbol(b21, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 12, 11))
+>b21 : string
 >{ b21: "string" } : { b21: string; }
->b21 : string, Symbol(b21, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 12, 21))
+>b21 : string
 >"string" : string
 >{ b2: { b21: "world" } } : { b2: { b21: string; }; }
->b2 : { b21: string; }, Symbol(b2, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 12, 44))
+>b2 : { b21: string; }
 >{ b21: "world" } : { b21: string; }
->b21 : string, Symbol(b21, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 12, 50))
+>b21 : string
 >"world" : string
 
 var {1: b3} = { 1: "string" };
->b3 : string, Symbol(b3, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 13, 5))
+>b3 : string
 >{ 1: "string" } : { 1: string; }
 >"string" : string
 
 var {b4 = 1}: any = { b4: 100000 };
->b4 : number, Symbol(b4, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 14, 5))
+>b4 : number
 >1 : number
 >{ b4: 100000 } : { b4: number; }
->b4 : number, Symbol(b4, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 14, 21))
+>b4 : number
 >100000 : number
 
 var {b5: { b52 }  } = { b5: { b52 } };
 >b5 : any
->b52 : any, Symbol(b52, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 15, 10))
+>b52 : any
 >{ b5: { b52 } } : { b5: { b52: any; }; }
->b5 : { b52: any; }, Symbol(b5, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 15, 23))
+>b5 : { b52: any; }
 >{ b52 } : { b52: any; }
->b52 : any, Symbol(b52, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 15, 29))
+>b52 : any
 
 // V is an object assignment pattern and, for each assignment property P in V,
 //      P specifies a numeric property name and S has a numeric index signature
 //          of a type that is assignable to the target given in P, or
 
 interface F {
->F : F, Symbol(F, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 15, 38))
+>F : F
 
     [idx: number]: boolean;
->idx : number, Symbol(idx, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 22, 5))
+>idx : number
 }
 
 function foo(): F {
->foo : () => F, Symbol(foo, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 23, 1))
->F : F, Symbol(F, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 15, 38))
+>foo : () => F
+>F : F
 
     return {
 >{        1: true    } : { [x: number]: boolean; 1: boolean; }
@@ -78,8 +78,8 @@ function foo(): F {
 }
 
 function bar(): F {
->bar : () => F, Symbol(bar, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 29, 1))
->F : F, Symbol(F, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 15, 38))
+>bar : () => F
+>F : F
 
     return {
 >{        2: true    } : { [x: number]: boolean; 2: boolean; }
@@ -90,28 +90,28 @@ function bar(): F {
     };
 }
 var {1: c0} = foo();
->c0 : boolean, Symbol(c0, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 36, 5))
+>c0 : boolean
 >foo() : F
->foo : () => F, Symbol(foo, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 23, 1))
+>foo : () => F
 
 var {1: c1} = bar();
->c1 : boolean, Symbol(c1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 37, 5))
+>c1 : boolean
 >bar() : F
->bar : () => F, Symbol(bar, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 29, 1))
+>bar : () => F
 
 // V is an object assignment pattern and, for each assignment property P in V,
 //      S has a string index signature of a type that is assignable to the target given in P
 
 interface F1 {
->F1 : F1, Symbol(F1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 37, 20))
+>F1 : F1
 
     [str: string]: number;
->str : string, Symbol(str, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 43, 5))
+>str : string
 }
 
 function foo1(): F1 {
->foo1 : () => F1, Symbol(foo1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 44, 1))
->F1 : F1, Symbol(F1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 37, 20))
+>foo1 : () => F1
+>F1 : F1
 
     return {
 >{        "prop1": 2    } : { [x: string]: number; "prop1": number; }
@@ -122,12 +122,12 @@ function foo1(): F1 {
 }
 
 var {"prop1": d1} = foo1();
->d1 : number, Symbol(d1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 52, 5), Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 53, 5))
+>d1 : number
 >foo1() : F1
->foo1 : () => F1, Symbol(foo1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 44, 1))
+>foo1 : () => F1
 
 var {"prop2": d1} = foo1();
->d1 : number, Symbol(d1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 52, 5), Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 53, 5))
+>d1 : number
 >foo1() : F1
->foo1 : () => F1, Symbol(foo1, Decl(destructuringObjectBindingPatternAndAssignment1ES6.ts, 44, 1))
+>foo1 : () => F1
 

tests/baselines/reference/destructuringObjectBindingPatternAndAssignment3.js

@@ -12,12 +12,12 @@ var {"prop"} = { "prop": 1 };
 
 //// [destructuringObjectBindingPatternAndAssignment3.js]
 // Error
-var h = ({ h: 1 }).h;
-var i = ({ i: 2 }).i;
-var i1 = ({ i1: 2 }).i1;
+var h = { h: 1 }.h;
+var i = { i: 2 }.i;
+var i1 = { i1: 2 }.i1;
 var _a = undefined.f2, f21 = (_a === void 0 ? { f212: "string" } : _a).f21;
-var d1 = ({
+var d1 = {
     a: 1, b: 1, d1: 9, e: 10
-}).d1;
-var  = ({ 1:  })[1];
-var  = ({ "prop": 1 })["prop"];
+}.d1;
+var  = { 1:  }[1];
+var  = { "prop": 1 }["prop"];

tests/baselines/reference/destructuringVariableDeclaration1ES5.js

@@ -48,30 +48,30 @@ var _a = { a1: 10, a2: "world" }, a1 = _a.a1, a2 = _a.a2;
 var _b = [1, [["hello"]], true], a3 = _b[0], a4 = _b[1][0][0], a5 = _b[2];
 // The type T associated with a destructuring variable declaration is determined as follows:
 //      Otherwise, if the declaration includes an initializer expression, T is the type of that initializer expression.
-var _c = ({ b1: { b11: "world" } }).b1, b11 = (_c === void 0 ? { b11: "string" } : _c).b11;
+var _c = { b1: { b11: "world" } }.b1, b11 = (_c === void 0 ? { b11: "string" } : _c).b11;
 var temp = { t1: true, t2: "false" };
 var _d = [3, false, { t1: false, t2: "hello" }], _e = _d[0], b2 = _e === void 0 ? 3 : _e, _f = _d[1], b3 = _f === void 0 ? true : _f, _g = _d[2], b4 = _g === void 0 ? temp : _g;
 var _h = [undefined, undefined, undefined], _j = _h[0], b5 = _j === void 0 ? 3 : _j, _k = _h[1], b6 = _k === void 0 ? true : _k, _l = _h[2], b7 = _l === void 0 ? temp : _l;
 // The type T associated with a binding element is determined as follows:
 //      If the binding element is a rest element, T is an array type with
 //          an element type E, where E is the type of the numeric index signature of S.
-var _m = [1, 2, 3], c1 = _m.slice(0);
-var _o = [1, 2, 3, "string"], c2 = _o.slice(0);
+var c1 = [1, 2, 3].slice(0);
+var c2 = [1, 2, 3, "string"].slice(0);
 // The type T associated with a binding element is determined as follows:
 //      Otherwise, if S is a tuple- like type (section 3.3.3):
 //          	Let N be the zero-based index of the binding element in the array binding pattern.
 // 	            If S has a property with the numerical name N, T is the type of that property.
-var _p = [1, "string"], d1 = _p[0], d2 = _p[1];
+var _m = [1, "string"], d1 = _m[0], d2 = _m[1];
 // The type T associated with a binding element is determined as follows:
 //      Otherwise, if S is a tuple- like type (section 3.3.3):
 //              Otherwise, if S has a numeric index signature, T is the type of the numeric index signature.
 var temp1 = [true, false, true];
-var _q = [1, "string"].concat(temp1), d3 = _q[0], d4 = _q[1];
+var _o = [1, "string"].concat(temp1), d3 = _o[0], d4 = _o[1];
 //  Combining both forms of destructuring,
-var _r = ({ e: [1, 2, { b1: 4, b4: 0 }] }).e, e1 = _r[0], e2 = _r[1], _s = _r[2], e3 = _s === void 0 ? { b1: 1000, b4: 200 } : _s;
-var _t = ({ f: [1, 2, { f3: 4, f5: 0 }] }).f, f1 = _t[0], f2 = _t[1], _u = _t[2], f4 = _u.f3, f5 = _u.f5;
+var _p = { e: [1, 2, { b1: 4, b4: 0 }] }.e, e1 = _p[0], e2 = _p[1], _q = _p[2], e3 = _q === void 0 ? { b1: 1000, b4: 200 } : _q;
+var _r = { f: [1, 2, { f3: 4, f5: 0 }] }.f, f1 = _r[0], f2 = _r[1], _s = _r[2], f4 = _s.f3, f5 = _s.f5;
 // When a destructuring variable declaration, binding property, or binding element specifies
 // an initializer expression, the type of the initializer expression is required to be assignable
 // to the widened form of the type associated with the destructuring variable declaration, binding property, or binding element.
-var _v = ({ g: { g1: [1, 2] } }).g.g1, g1 = _v === void 0 ? [undefined, null] : _v;
-var _w = ({ h: { h1: [1, 2] } }).h.h1, h1 = _w === void 0 ? [undefined, null] : _w;
+var _t = { g: { g1: [1, 2] } }.g.g1, g1 = _t === void 0 ? [undefined, null] : _t;
+var _u = { h: { h1: [1, 2] } }.h.h1, h1 = _u === void 0 ? [undefined, null] : _u;

tests/baselines/reference/destructuringVariableDeclaration1ES5.symbols

@@ -0,0 +1,114 @@
+=== tests/cases/conformance/es6/destructuring/destructuringVariableDeclaration1ES5.ts ===
+// The type T associated with a destructuring variable declaration is determined as follows:
+//      If the declaration includes a type annotation, T is that type.
+var {a1, a2}: { a1: number, a2: string } = { a1: 10, a2: "world" }
+>a1 : Symbol(a1, Decl(destructuringVariableDeclaration1ES5.ts, 2, 5))
+>a2 : Symbol(a2, Decl(destructuringVariableDeclaration1ES5.ts, 2, 8))
+>a1 : Symbol(a1, Decl(destructuringVariableDeclaration1ES5.ts, 2, 15))
+>a2 : Symbol(a2, Decl(destructuringVariableDeclaration1ES5.ts, 2, 27))
+>a1 : Symbol(a1, Decl(destructuringVariableDeclaration1ES5.ts, 2, 44))
+>a2 : Symbol(a2, Decl(destructuringVariableDeclaration1ES5.ts, 2, 52))
+
+var [a3, [[a4]], a5]: [number, [[string]], boolean] = [1, [["hello"]], true];
+>a3 : Symbol(a3, Decl(destructuringVariableDeclaration1ES5.ts, 3, 5))
+>a4 : Symbol(a4, Decl(destructuringVariableDeclaration1ES5.ts, 3, 11))
+>a5 : Symbol(a5, Decl(destructuringVariableDeclaration1ES5.ts, 3, 16))
+
+// The type T associated with a destructuring variable declaration is determined as follows:
+//      Otherwise, if the declaration includes an initializer expression, T is the type of that initializer expression.
+var { b1: { b11 } = { b11: "string" }  } = { b1: { b11: "world" } };
+>b11 : Symbol(b11, Decl(destructuringVariableDeclaration1ES5.ts, 7, 11))
+>b11 : Symbol(b11, Decl(destructuringVariableDeclaration1ES5.ts, 7, 21))
+>b1 : Symbol(b1, Decl(destructuringVariableDeclaration1ES5.ts, 7, 44))
+>b11 : Symbol(b11, Decl(destructuringVariableDeclaration1ES5.ts, 7, 50))
+
+var temp = { t1: true, t2: "false" };
+>temp : Symbol(temp, Decl(destructuringVariableDeclaration1ES5.ts, 8, 3))
+>t1 : Symbol(t1, Decl(destructuringVariableDeclaration1ES5.ts, 8, 12))
+>t2 : Symbol(t2, Decl(destructuringVariableDeclaration1ES5.ts, 8, 22))
+
+var [b2 = 3, b3 = true, b4 = temp] = [3, false, { t1: false, t2: "hello" }];
+>b2 : Symbol(b2, Decl(destructuringVariableDeclaration1ES5.ts, 9, 5))
+>b3 : Symbol(b3, Decl(destructuringVariableDeclaration1ES5.ts, 9, 12))
+>b4 : Symbol(b4, Decl(destructuringVariableDeclaration1ES5.ts, 9, 23))
+>temp : Symbol(temp, Decl(destructuringVariableDeclaration1ES5.ts, 8, 3))
+>t1 : Symbol(t1, Decl(destructuringVariableDeclaration1ES5.ts, 9, 49))
+>t2 : Symbol(t2, Decl(destructuringVariableDeclaration1ES5.ts, 9, 60))
+
+var [b5 = 3, b6 = true, b7 = temp] = [undefined, undefined, undefined];
+>b5 : Symbol(b5, Decl(destructuringVariableDeclaration1ES5.ts, 10, 5))
+>b6 : Symbol(b6, Decl(destructuringVariableDeclaration1ES5.ts, 10, 12))
+>b7 : Symbol(b7, Decl(destructuringVariableDeclaration1ES5.ts, 10, 23))
+>temp : Symbol(temp, Decl(destructuringVariableDeclaration1ES5.ts, 8, 3))
+>undefined : Symbol(undefined)
+>undefined : Symbol(undefined)
+>undefined : Symbol(undefined)
+
+// The type T associated with a binding element is determined as follows:
+//      If the binding element is a rest element, T is an array type with
+//          an element type E, where E is the type of the numeric index signature of S.
+var [...c1] = [1,2,3]; 
+>c1 : Symbol(c1, Decl(destructuringVariableDeclaration1ES5.ts, 15, 5))
+
+var [...c2] = [1,2,3, "string"]; 
+>c2 : Symbol(c2, Decl(destructuringVariableDeclaration1ES5.ts, 16, 5))
+
+// The type T associated with a binding element is determined as follows:
+//      Otherwise, if S is a tuple- like type (section 3.3.3):
+//          	Let N be the zero-based index of the binding element in the array binding pattern.
+// 	            If S has a property with the numerical name N, T is the type of that property.
+var [d1,d2] = [1,"string"]	
+>d1 : Symbol(d1, Decl(destructuringVariableDeclaration1ES5.ts, 22, 5))
+>d2 : Symbol(d2, Decl(destructuringVariableDeclaration1ES5.ts, 22, 8))
+
+// The type T associated with a binding element is determined as follows:
+//      Otherwise, if S is a tuple- like type (section 3.3.3):
+//              Otherwise, if S has a numeric index signature, T is the type of the numeric index signature.
+var temp1 = [true, false, true]
+>temp1 : Symbol(temp1, Decl(destructuringVariableDeclaration1ES5.ts, 27, 3))
+
+var [d3, d4] = [1, "string", ...temp1];
+>d3 : Symbol(d3, Decl(destructuringVariableDeclaration1ES5.ts, 28, 5))
+>d4 : Symbol(d4, Decl(destructuringVariableDeclaration1ES5.ts, 28, 8))
+>temp1 : Symbol(temp1, Decl(destructuringVariableDeclaration1ES5.ts, 27, 3))
+
+//  Combining both forms of destructuring,
+var {e: [e1, e2, e3 = { b1: 1000, b4: 200 }]} = { e: [1, 2, { b1: 4, b4: 0 }] }; 
+>e1 : Symbol(e1, Decl(destructuringVariableDeclaration1ES5.ts, 31, 9))
+>e2 : Symbol(e2, Decl(destructuringVariableDeclaration1ES5.ts, 31, 12))
+>e3 : Symbol(e3, Decl(destructuringVariableDeclaration1ES5.ts, 31, 16))
+>b1 : Symbol(b1, Decl(destructuringVariableDeclaration1ES5.ts, 31, 23))
+>b4 : Symbol(b4, Decl(destructuringVariableDeclaration1ES5.ts, 31, 33))
+>e : Symbol(e, Decl(destructuringVariableDeclaration1ES5.ts, 31, 49))
+>b1 : Symbol(b1, Decl(destructuringVariableDeclaration1ES5.ts, 31, 61))
+>b4 : Symbol(b4, Decl(destructuringVariableDeclaration1ES5.ts, 31, 68))
+
+var {f: [f1, f2, { f3: f4, f5 }, , ]} = { f: [1, 2, { f3: 4, f5: 0 }] };
+>f1 : Symbol(f1, Decl(destructuringVariableDeclaration1ES5.ts, 32, 9))
+>f2 : Symbol(f2, Decl(destructuringVariableDeclaration1ES5.ts, 32, 12))
+>f4 : Symbol(f4, Decl(destructuringVariableDeclaration1ES5.ts, 32, 18))
+>f5 : Symbol(f5, Decl(destructuringVariableDeclaration1ES5.ts, 32, 26))
+>f : Symbol(f, Decl(destructuringVariableDeclaration1ES5.ts, 32, 41))
+>f3 : Symbol(f3, Decl(destructuringVariableDeclaration1ES5.ts, 32, 53))
+>f5 : Symbol(f5, Decl(destructuringVariableDeclaration1ES5.ts, 32, 60))
+
+// When a destructuring variable declaration, binding property, or binding element specifies
+// an initializer expression, the type of the initializer expression is required to be assignable
+// to the widened form of the type associated with the destructuring variable declaration, binding property, or binding element.
+var {g: {g1 = [undefined, null]}}: { g: { g1: any[] } } = { g: { g1: [1, 2] } };
+>g1 : Symbol(g1, Decl(destructuringVariableDeclaration1ES5.ts, 37, 9))
+>undefined : Symbol(undefined)
+>g : Symbol(g, Decl(destructuringVariableDeclaration1ES5.ts, 37, 36))
+>g1 : Symbol(g1, Decl(destructuringVariableDeclaration1ES5.ts, 37, 41))
+>g : Symbol(g, Decl(destructuringVariableDeclaration1ES5.ts, 37, 59))
+>g1 : Symbol(g1, Decl(destructuringVariableDeclaration1ES5.ts, 37, 64))
+
+var {h: {h1 = [undefined, null]}}: { h: { h1: number[] } } = { h: { h1: [1, 2] } };
+>h1 : Symbol(h1, Decl(destructuringVariableDeclaration1ES5.ts, 38, 9))
+>undefined : Symbol(undefined)
+>h : Symbol(h, Decl(destructuringVariableDeclaration1ES5.ts, 38, 36))
+>h1 : Symbol(h1, Decl(destructuringVariableDeclaration1ES5.ts, 38, 41))
+>h : Symbol(h, Decl(destructuringVariableDeclaration1ES5.ts, 38, 62))
+>h1 : Symbol(h1, Decl(destructuringVariableDeclaration1ES5.ts, 38, 67))
+
+

tests/baselines/reference/destructuringVariableDeclaration1ES5.types

@@ -2,20 +2,20 @@
 // The type T associated with a destructuring variable declaration is determined as follows:
 //      If the declaration includes a type annotation, T is that type.
 var {a1, a2}: { a1: number, a2: string } = { a1: 10, a2: "world" }
->a1 : number, Symbol(a1, Decl(destructuringVariableDeclaration1ES5.ts, 2, 5))
->a2 : string, Symbol(a2, Decl(destructuringVariableDeclaration1ES5.ts, 2, 8))
->a1 : number, Symbol(a1, Decl(destructuringVariableDeclaration1ES5.ts, 2, 15))
->a2 : string, Symbol(a2, Decl(destructuringVariableDeclaration1ES5.ts, 2, 27))
+>a1 : number
+>a2 : string
+>a1 : number
+>a2 : string
 >{ a1: 10, a2: "world" } : { a1: number; a2: string; }
->a1 : number, Symbol(a1, Decl(destructuringVariableDeclaration1ES5.ts, 2, 44))
+>a1 : number
 >10 : number
->a2 : string, Symbol(a2, Decl(destructuringVariableDeclaration1ES5.ts, 2, 52))
+>a2 : string
 >"world" : string
 
 var [a3, [[a4]], a5]: [number, [[string]], boolean] = [1, [["hello"]], true];
->a3 : number, Symbol(a3, Decl(destructuringVariableDeclaration1ES5.ts, 3, 5))
->a4 : string, Symbol(a4, Decl(destructuringVariableDeclaration1ES5.ts, 3, 11))
->a5 : boolean, Symbol(a5, Decl(destructuringVariableDeclaration1ES5.ts, 3, 16))
+>a3 : number
+>a4 : string
+>a5 : boolean
 >[1, [["hello"]], true] : [number, [[string]], boolean]
 >1 : number
 >[["hello"]] : [[string]]
@@ -27,64 +27,64 @@ var [a3, [[a4]], a5]: [number, [[string]], boolean] = [1, [["hello"]], true];
 //      Otherwise, if the declaration includes an initializer expression, T is the type of that initializer expression.
 var { b1: { b11 } = { b11: "string" }  } = { b1: { b11: "world" } };
 >b1 : any
->b11 : string, Symbol(b11, Decl(destructuringVariableDeclaration1ES5.ts, 7, 11))
+>b11 : string
 >{ b11: "string" } : { b11: string; }
->b11 : string, Symbol(b11, Decl(destructuringVariableDeclaration1ES5.ts, 7, 21))
+>b11 : string
 >"string" : string
 >{ b1: { b11: "world" } } : { b1: { b11: string; }; }
->b1 : { b11: string; }, Symbol(b1, Decl(destructuringVariableDeclaration1ES5.ts, 7, 44))
+>b1 : { b11: string; }
 >{ b11: "world" } : { b11: string; }
->b11 : string, Symbol(b11, Decl(destructuringVariableDeclaration1ES5.ts, 7, 50))
+>b11 : string
 >"world" : string
 
 var temp = { t1: true, t2: "false" };
->temp : { t1: boolean; t2: string; }, Symbol(temp, Decl(destructuringVariableDeclaration1ES5.ts, 8, 3))
+>temp : { t1: boolean; t2: string; }
 >{ t1: true, t2: "false" } : { t1: boolean; t2: string; }
->t1 : boolean, Symbol(t1, Decl(destructuringVariableDeclaration1ES5.ts, 8, 12))
+>t1 : boolean
 >true : boolean
->t2 : string, Symbol(t2, Decl(destructuringVariableDeclaration1ES5.ts, 8, 22))
+>t2 : string
 >"false" : string
 
 var [b2 = 3, b3 = true, b4 = temp] = [3, false, { t1: false, t2: "hello" }];
->b2 : number, Symbol(b2, Decl(destructuringVariableDeclaration1ES5.ts, 9, 5))
+>b2 : number
 >3 : number
->b3 : boolean, Symbol(b3, Decl(destructuringVariableDeclaration1ES5.ts, 9, 12))
+>b3 : boolean
 >true : boolean
->b4 : { t1: boolean; t2: string; }, Symbol(b4, Decl(destructuringVariableDeclaration1ES5.ts, 9, 23))
->temp : { t1: boolean; t2: string; }, Symbol(temp, Decl(destructuringVariableDeclaration1ES5.ts, 8, 3))
+>b4 : { t1: boolean; t2: string; }
+>temp : { t1: boolean; t2: string; }
 >[3, false, { t1: false, t2: "hello" }] : [number, boolean, { t1: boolean; t2: string; }]
 >3 : number
 >false : boolean
 >{ t1: false, t2: "hello" } : { t1: boolean; t2: string; }
->t1 : boolean, Symbol(t1, Decl(destructuringVariableDeclaration1ES5.ts, 9, 49))
+>t1 : boolean
 >false : boolean
->t2 : string, Symbol(t2, Decl(destructuringVariableDeclaration1ES5.ts, 9, 60))
+>t2 : string
 >"hello" : string
 
 var [b5 = 3, b6 = true, b7 = temp] = [undefined, undefined, undefined];
->b5 : any, Symbol(b5, Decl(destructuringVariableDeclaration1ES5.ts, 10, 5))
+>b5 : any
 >3 : number
->b6 : any, Symbol(b6, Decl(destructuringVariableDeclaration1ES5.ts, 10, 12))
+>b6 : any
 >true : boolean
->b7 : any, Symbol(b7, Decl(destructuringVariableDeclaration1ES5.ts, 10, 23))
->temp : { t1: boolean; t2: string; }, Symbol(temp, Decl(destructuringVariableDeclaration1ES5.ts, 8, 3))
+>b7 : any
+>temp : { t1: boolean; t2: string; }
 >[undefined, undefined, undefined] : [undefined, undefined, undefined]
->undefined : undefined, Symbol(undefined)
->undefined : undefined, Symbol(undefined)
->undefined : undefined, Symbol(undefined)
+>undefined : undefined
+>undefined : undefined
+>undefined : undefined
 
 // The type T associated with a binding element is determined as follows:
 //      If the binding element is a rest element, T is an array type with
 //          an element type E, where E is the type of the numeric index signature of S.
 var [...c1] = [1,2,3]; 
->c1 : number[], Symbol(c1, Decl(destructuringVariableDeclaration1ES5.ts, 15, 5))
+>c1 : number[]
 >[1,2,3] : number[]
 >1 : number
 >2 : number
 >3 : number
 
 var [...c2] = [1,2,3, "string"]; 
->c2 : (string | number)[], Symbol(c2, Decl(destructuringVariableDeclaration1ES5.ts, 16, 5))
+>c2 : (string | number)[]
 >[1,2,3, "string"] : (string | number)[]
 >1 : number
 >2 : number
@@ -96,8 +96,8 @@ var [...c2] = [1,2,3, "string"];
 //          	Let N be the zero-based index of the binding element in the array binding pattern.
 // 	            If S has a property with the numerical name N, T is the type of that property.
 var [d1,d2] = [1,"string"]	
->d1 : number, Symbol(d1, Decl(destructuringVariableDeclaration1ES5.ts, 22, 5))
->d2 : string, Symbol(d2, Decl(destructuringVariableDeclaration1ES5.ts, 22, 8))
+>d1 : number
+>d2 : string
 >[1,"string"] : [number, string]
 >1 : number
 >"string" : string
@@ -106,60 +106,60 @@ var [d1,d2] = [1,"string"]
 //      Otherwise, if S is a tuple- like type (section 3.3.3):
 //              Otherwise, if S has a numeric index signature, T is the type of the numeric index signature.
 var temp1 = [true, false, true]
->temp1 : boolean[], Symbol(temp1, Decl(destructuringVariableDeclaration1ES5.ts, 27, 3))
+>temp1 : boolean[]
 >[true, false, true] : boolean[]
 >true : boolean
 >false : boolean
 >true : boolean
 
 var [d3, d4] = [1, "string", ...temp1];
->d3 : string | number | boolean, Symbol(d3, Decl(destructuringVariableDeclaration1ES5.ts, 28, 5))
->d4 : string | number | boolean, Symbol(d4, Decl(destructuringVariableDeclaration1ES5.ts, 28, 8))
+>d3 : string | number | boolean
+>d4 : string | number | boolean
 >[1, "string", ...temp1] : (string | number | boolean)[]
 >1 : number
 >"string" : string
 >...temp1 : boolean
->temp1 : boolean[], Symbol(temp1, Decl(destructuringVariableDeclaration1ES5.ts, 27, 3))
+>temp1 : boolean[]
 
 //  Combining both forms of destructuring,
 var {e: [e1, e2, e3 = { b1: 1000, b4: 200 }]} = { e: [1, 2, { b1: 4, b4: 0 }] }; 
 >e : any
->e1 : number, Symbol(e1, Decl(destructuringVariableDeclaration1ES5.ts, 31, 9))
->e2 : number, Symbol(e2, Decl(destructuringVariableDeclaration1ES5.ts, 31, 12))
->e3 : { b1: number; b4: number; }, Symbol(e3, Decl(destructuringVariableDeclaration1ES5.ts, 31, 16))
+>e1 : number
+>e2 : number
+>e3 : { b1: number; b4: number; }
 >{ b1: 1000, b4: 200 } : { b1: number; b4: number; }
->b1 : number, Symbol(b1, Decl(destructuringVariableDeclaration1ES5.ts, 31, 23))
+>b1 : number
 >1000 : number
->b4 : number, Symbol(b4, Decl(destructuringVariableDeclaration1ES5.ts, 31, 33))
+>b4 : number
 >200 : number
 >{ e: [1, 2, { b1: 4, b4: 0 }] } : { e: [number, number, { b1: number; b4: number; }]; }
->e : [number, number, { b1: number; b4: number; }], Symbol(e, Decl(destructuringVariableDeclaration1ES5.ts, 31, 49))
+>e : [number, number, { b1: number; b4: number; }]
 >[1, 2, { b1: 4, b4: 0 }] : [number, number, { b1: number; b4: number; }]
 >1 : number
 >2 : number
 >{ b1: 4, b4: 0 } : { b1: number; b4: number; }
->b1 : number, Symbol(b1, Decl(destructuringVariableDeclaration1ES5.ts, 31, 61))
+>b1 : number
 >4 : number
->b4 : number, Symbol(b4, Decl(destructuringVariableDeclaration1ES5.ts, 31, 68))
+>b4 : number
 >0 : number
 
 var {f: [f1, f2, { f3: f4, f5 }, , ]} = { f: [1, 2, { f3: 4, f5: 0 }] };
 >f : any
->f1 : number, Symbol(f1, Decl(destructuringVariableDeclaration1ES5.ts, 32, 9))
->f2 : number, Symbol(f2, Decl(destructuringVariableDeclaration1ES5.ts, 32, 12))
+>f1 : number
+>f2 : number
 >f3 : any
->f4 : number, Symbol(f4, Decl(destructuringVariableDeclaration1ES5.ts, 32, 18))
->f5 : number, Symbol(f5, Decl(destructuringVariableDeclaration1ES5.ts, 32, 26))
+>f4 : number
+>f5 : number
 > : undefined
 >{ f: [1, 2, { f3: 4, f5: 0 }] } : { f: [number, number, { f3: number; f5: number; }]; }
->f : [number, number, { f3: number; f5: number; }], Symbol(f, Decl(destructuringVariableDeclaration1ES5.ts, 32, 41))
+>f : [number, number, { f3: number; f5: number; }]
 >[1, 2, { f3: 4, f5: 0 }] : [number, number, { f3: number; f5: number; }]
 >1 : number
 >2 : number
 >{ f3: 4, f5: 0 } : { f3: number; f5: number; }
->f3 : number, Symbol(f3, Decl(destructuringVariableDeclaration1ES5.ts, 32, 53))
+>f3 : number
 >4 : number
->f5 : number, Symbol(f5, Decl(destructuringVariableDeclaration1ES5.ts, 32, 60))
+>f5 : number
 >0 : number
 
 // When a destructuring variable declaration, binding property, or binding element specifies
@@ -167,32 +167,32 @@ var {f: [f1, f2, { f3: f4, f5 }, , ]} = { f: [1, 2, { f3: 4, f5: 0 }] };
 // to the widened form of the type associated with the destructuring variable declaration, binding property, or binding element.
 var {g: {g1 = [undefined, null]}}: { g: { g1: any[] } } = { g: { g1: [1, 2] } };
 >g : any
->g1 : any[], Symbol(g1, Decl(destructuringVariableDeclaration1ES5.ts, 37, 9))
+>g1 : any[]
 >[undefined, null] : null[]
->undefined : undefined, Symbol(undefined)
+>undefined : undefined
 >null : null
->g : { g1: any[]; }, Symbol(g, Decl(destructuringVariableDeclaration1ES5.ts, 37, 36))
->g1 : any[], Symbol(g1, Decl(destructuringVariableDeclaration1ES5.ts, 37, 41))
+>g : { g1: any[]; }
+>g1 : any[]
 >{ g: { g1: [1, 2] } } : { g: { g1: number[]; }; }
->g : { g1: number[]; }, Symbol(g, Decl(destructuringVariableDeclaration1ES5.ts, 37, 59))
+>g : { g1: number[]; }
 >{ g1: [1, 2] } : { g1: number[]; }
->g1 : number[], Symbol(g1, Decl(destructuringVariableDeclaration1ES5.ts, 37, 64))
+>g1 : number[]
 >[1, 2] : number[]
 >1 : number
 >2 : number
 
 var {h: {h1 = [undefined, null]}}: { h: { h1: number[] } } = { h: { h1: [1, 2] } };
 >h : any
->h1 : number[], Symbol(h1, Decl(destructuringVariableDeclaration1ES5.ts, 38, 9))
+>h1 : number[]
 >[undefined, null] : null[]
->undefined : undefined, Symbol(undefined)
+>undefined : undefined
 >null : null
->h : { h1: number[]; }, Symbol(h, Decl(destructuringVariableDeclaration1ES5.ts, 38, 36))
->h1 : number[], Symbol(h1, Decl(destructuringVariableDeclaration1ES5.ts, 38, 41))
+>h : { h1: number[]; }
+>h1 : number[]
 >{ h: { h1: [1, 2] } } : { h: { h1: number[]; }; }
->h : { h1: number[]; }, Symbol(h, Decl(destructuringVariableDeclaration1ES5.ts, 38, 62))
+>h : { h1: number[]; }
 >{ h1: [1, 2] } : { h1: number[]; }
->h1 : number[], Symbol(h1, Decl(destructuringVariableDeclaration1ES5.ts, 38, 67))
+>h1 : number[]
 >[1, 2] : number[]
 >1 : number
 >2 : number

tests/baselines/reference/destructuringVariableDeclaration1ES6.symbols

@@ -0,0 +1,114 @@
+=== tests/cases/conformance/es6/destructuring/destructuringVariableDeclaration1ES6.ts ===
+// The type T associated with a destructuring variable declaration is determined as follows:
+//      If the declaration includes a type annotation, T is that type.
+var {a1, a2}: { a1: number, a2: string } = { a1: 10, a2: "world" }
+>a1 : Symbol(a1, Decl(destructuringVariableDeclaration1ES6.ts, 2, 5))
+>a2 : Symbol(a2, Decl(destructuringVariableDeclaration1ES6.ts, 2, 8))
+>a1 : Symbol(a1, Decl(destructuringVariableDeclaration1ES6.ts, 2, 15))
+>a2 : Symbol(a2, Decl(destructuringVariableDeclaration1ES6.ts, 2, 27))
+>a1 : Symbol(a1, Decl(destructuringVariableDeclaration1ES6.ts, 2, 44))
+>a2 : Symbol(a2, Decl(destructuringVariableDeclaration1ES6.ts, 2, 52))
+
+var [a3, [[a4]], a5]: [number, [[string]], boolean] = [1, [["hello"]], true];
+>a3 : Symbol(a3, Decl(destructuringVariableDeclaration1ES6.ts, 3, 5))
+>a4 : Symbol(a4, Decl(destructuringVariableDeclaration1ES6.ts, 3, 11))
+>a5 : Symbol(a5, Decl(destructuringVariableDeclaration1ES6.ts, 3, 16))
+
+// The type T associated with a destructuring variable declaration is determined as follows:
+//      Otherwise, if the declaration includes an initializer expression, T is the type of that initializer expression.
+var { b1: { b11 } = { b11: "string" }  } = { b1: { b11: "world" } };
+>b11 : Symbol(b11, Decl(destructuringVariableDeclaration1ES6.ts, 7, 11))
+>b11 : Symbol(b11, Decl(destructuringVariableDeclaration1ES6.ts, 7, 21))
+>b1 : Symbol(b1, Decl(destructuringVariableDeclaration1ES6.ts, 7, 44))
+>b11 : Symbol(b11, Decl(destructuringVariableDeclaration1ES6.ts, 7, 50))
+
+var temp = { t1: true, t2: "false" };
+>temp : Symbol(temp, Decl(destructuringVariableDeclaration1ES6.ts, 8, 3))
+>t1 : Symbol(t1, Decl(destructuringVariableDeclaration1ES6.ts, 8, 12))
+>t2 : Symbol(t2, Decl(destructuringVariableDeclaration1ES6.ts, 8, 22))
+
+var [b2 = 3, b3 = true, b4 = temp] = [3, false, { t1: false, t2: "hello" }];
+>b2 : Symbol(b2, Decl(destructuringVariableDeclaration1ES6.ts, 9, 5))
+>b3 : Symbol(b3, Decl(destructuringVariableDeclaration1ES6.ts, 9, 12))
+>b4 : Symbol(b4, Decl(destructuringVariableDeclaration1ES6.ts, 9, 23))
+>temp : Symbol(temp, Decl(destructuringVariableDeclaration1ES6.ts, 8, 3))
+>t1 : Symbol(t1, Decl(destructuringVariableDeclaration1ES6.ts, 9, 49))
+>t2 : Symbol(t2, Decl(destructuringVariableDeclaration1ES6.ts, 9, 60))
+
+var [b5 = 3, b6 = true, b7 = temp] = [undefined, undefined, undefined];
+>b5 : Symbol(b5, Decl(destructuringVariableDeclaration1ES6.ts, 10, 5))
+>b6 : Symbol(b6, Decl(destructuringVariableDeclaration1ES6.ts, 10, 12))
+>b7 : Symbol(b7, Decl(destructuringVariableDeclaration1ES6.ts, 10, 23))
+>temp : Symbol(temp, Decl(destructuringVariableDeclaration1ES6.ts, 8, 3))
+>undefined : Symbol(undefined)
+>undefined : Symbol(undefined)
+>undefined : Symbol(undefined)
+
+// The type T associated with a binding element is determined as follows:
+//      If the binding element is a rest element, T is an array type with
+//          an element type E, where E is the type of the numeric index signature of S.
+var [...c1] = [1,2,3]; 
+>c1 : Symbol(c1, Decl(destructuringVariableDeclaration1ES6.ts, 15, 5))
+
+var [...c2] = [1,2,3, "string"]; 
+>c2 : Symbol(c2, Decl(destructuringVariableDeclaration1ES6.ts, 16, 5))
+
+// The type T associated with a binding element is determined as follows:
+//      Otherwise, if S is a tuple- like type (section 3.3.3):
+//          	Let N be the zero-based index of the binding element in the array binding pattern.
+// 	            If S has a property with the numerical name N, T is the type of that property.
+var [d1,d2] = [1,"string"]	
+>d1 : Symbol(d1, Decl(destructuringVariableDeclaration1ES6.ts, 22, 5))
+>d2 : Symbol(d2, Decl(destructuringVariableDeclaration1ES6.ts, 22, 8))
+
+// The type T associated with a binding element is determined as follows:
+//      Otherwise, if S is a tuple- like type (section 3.3.3):
+//              Otherwise, if S has a numeric index signature, T is the type of the numeric index signature.
+var temp1 = [true, false, true]
+>temp1 : Symbol(temp1, Decl(destructuringVariableDeclaration1ES6.ts, 27, 3))
+
+var [d3, d4] = [1, "string", ...temp1];
+>d3 : Symbol(d3, Decl(destructuringVariableDeclaration1ES6.ts, 28, 5))
+>d4 : Symbol(d4, Decl(destructuringVariableDeclaration1ES6.ts, 28, 8))
+>temp1 : Symbol(temp1, Decl(destructuringVariableDeclaration1ES6.ts, 27, 3))
+
+//  Combining both forms of destructuring,
+var {e: [e1, e2, e3 = { b1: 1000, b4: 200 }]} = { e: [1, 2, { b1: 4, b4: 0 }] }; 
+>e1 : Symbol(e1, Decl(destructuringVariableDeclaration1ES6.ts, 31, 9))
+>e2 : Symbol(e2, Decl(destructuringVariableDeclaration1ES6.ts, 31, 12))
+>e3 : Symbol(e3, Decl(destructuringVariableDeclaration1ES6.ts, 31, 16))
+>b1 : Symbol(b1, Decl(destructuringVariableDeclaration1ES6.ts, 31, 23))
+>b4 : Symbol(b4, Decl(destructuringVariableDeclaration1ES6.ts, 31, 33))
+>e : Symbol(e, Decl(destructuringVariableDeclaration1ES6.ts, 31, 49))
+>b1 : Symbol(b1, Decl(destructuringVariableDeclaration1ES6.ts, 31, 61))
+>b4 : Symbol(b4, Decl(destructuringVariableDeclaration1ES6.ts, 31, 68))
+
+var {f: [f1, f2, { f3: f4, f5 }, , ]} = { f: [1, 2, { f3: 4, f5: 0 }] };
+>f1 : Symbol(f1, Decl(destructuringVariableDeclaration1ES6.ts, 32, 9))
+>f2 : Symbol(f2, Decl(destructuringVariableDeclaration1ES6.ts, 32, 12))
+>f4 : Symbol(f4, Decl(destructuringVariableDeclaration1ES6.ts, 32, 18))
+>f5 : Symbol(f5, Decl(destructuringVariableDeclaration1ES6.ts, 32, 26))
+>f : Symbol(f, Decl(destructuringVariableDeclaration1ES6.ts, 32, 41))
+>f3 : Symbol(f3, Decl(destructuringVariableDeclaration1ES6.ts, 32, 53))
+>f5 : Symbol(f5, Decl(destructuringVariableDeclaration1ES6.ts, 32, 60))
+
+// When a destructuring variable declaration, binding property, or binding element specifies
+// an initializer expression, the type of the initializer expression is required to be assignable
+// to the widened form of the type associated with the destructuring variable declaration, binding property, or binding element.
+var {g: {g1 = [undefined, null]}}: { g: { g1: any[] } } = { g: { g1: [1, 2] } };
+>g1 : Symbol(g1, Decl(destructuringVariableDeclaration1ES6.ts, 37, 9))
+>undefined : Symbol(undefined)
+>g : Symbol(g, Decl(destructuringVariableDeclaration1ES6.ts, 37, 36))
+>g1 : Symbol(g1, Decl(destructuringVariableDeclaration1ES6.ts, 37, 41))
+>g : Symbol(g, Decl(destructuringVariableDeclaration1ES6.ts, 37, 59))
+>g1 : Symbol(g1, Decl(destructuringVariableDeclaration1ES6.ts, 37, 64))
+
+var {h: {h1 = [undefined, null]}}: { h: { h1: number[] } } = { h: { h1: [1, 2] } };
+>h1 : Symbol(h1, Decl(destructuringVariableDeclaration1ES6.ts, 38, 9))
+>undefined : Symbol(undefined)
+>h : Symbol(h, Decl(destructuringVariableDeclaration1ES6.ts, 38, 36))
+>h1 : Symbol(h1, Decl(destructuringVariableDeclaration1ES6.ts, 38, 41))
+>h : Symbol(h, Decl(destructuringVariableDeclaration1ES6.ts, 38, 62))
+>h1 : Symbol(h1, Decl(destructuringVariableDeclaration1ES6.ts, 38, 67))
+
+

tests/baselines/reference/destructuringVariableDeclaration1ES6.types

@@ -2,20 +2,20 @@
 // The type T associated with a destructuring variable declaration is determined as follows:
 //      If the declaration includes a type annotation, T is that type.
 var {a1, a2}: { a1: number, a2: string } = { a1: 10, a2: "world" }
->a1 : number, Symbol(a1, Decl(destructuringVariableDeclaration1ES6.ts, 2, 5))
->a2 : string, Symbol(a2, Decl(destructuringVariableDeclaration1ES6.ts, 2, 8))
->a1 : number, Symbol(a1, Decl(destructuringVariableDeclaration1ES6.ts, 2, 15))
->a2 : string, Symbol(a2, Decl(destructuringVariableDeclaration1ES6.ts, 2, 27))
+>a1 : number
+>a2 : string
+>a1 : number
+>a2 : string
 >{ a1: 10, a2: "world" } : { a1: number; a2: string; }
->a1 : number, Symbol(a1, Decl(destructuringVariableDeclaration1ES6.ts, 2, 44))
+>a1 : number
 >10 : number
->a2 : string, Symbol(a2, Decl(destructuringVariableDeclaration1ES6.ts, 2, 52))
+>a2 : string
 >"world" : string
 
 var [a3, [[a4]], a5]: [number, [[string]], boolean] = [1, [["hello"]], true];
->a3 : number, Symbol(a3, Decl(destructuringVariableDeclaration1ES6.ts, 3, 5))
->a4 : string, Symbol(a4, Decl(destructuringVariableDeclaration1ES6.ts, 3, 11))
->a5 : boolean, Symbol(a5, Decl(destructuringVariableDeclaration1ES6.ts, 3, 16))
+>a3 : number
+>a4 : string
+>a5 : boolean
 >[1, [["hello"]], true] : [number, [[string]], boolean]
 >1 : number
 >[["hello"]] : [[string]]
@@ -27,64 +27,64 @@ var [a3, [[a4]], a5]: [number, [[string]], boolean] = [1, [["hello"]], true];
 //      Otherwise, if the declaration includes an initializer expression, T is the type of that initializer expression.
 var { b1: { b11 } = { b11: "string" }  } = { b1: { b11: "world" } };
 >b1 : any
->b11 : string, Symbol(b11, Decl(destructuringVariableDeclaration1ES6.ts, 7, 11))
+>b11 : string
 >{ b11: "string" } : { b11: string; }
->b11 : string, Symbol(b11, Decl(destructuringVariableDeclaration1ES6.ts, 7, 21))
+>b11 : string
 >"string" : string
 >{ b1: { b11: "world" } } : { b1: { b11: string; }; }
->b1 : { b11: string; }, Symbol(b1, Decl(destructuringVariableDeclaration1ES6.ts, 7, 44))
+>b1 : { b11: string; }
 >{ b11: "world" } : { b11: string; }
->b11 : string, Symbol(b11, Decl(destructuringVariableDeclaration1ES6.ts, 7, 50))
+>b11 : string
 >"world" : string
 
 var temp = { t1: true, t2: "false" };
->temp : { t1: boolean; t2: string; }, Symbol(temp, Decl(destructuringVariableDeclaration1ES6.ts, 8, 3))
+>temp : { t1: boolean; t2: string; }
 >{ t1: true, t2: "false" } : { t1: boolean; t2: string; }
->t1 : boolean, Symbol(t1, Decl(destructuringVariableDeclaration1ES6.ts, 8, 12))
+>t1 : boolean
 >true : boolean
->t2 : string, Symbol(t2, Decl(destructuringVariableDeclaration1ES6.ts, 8, 22))
+>t2 : string
 >"false" : string
 
 var [b2 = 3, b3 = true, b4 = temp] = [3, false, { t1: false, t2: "hello" }];
->b2 : number, Symbol(b2, Decl(destructuringVariableDeclaration1ES6.ts, 9, 5))
+>b2 : number
 >3 : number
->b3 : boolean, Symbol(b3, Decl(destructuringVariableDeclaration1ES6.ts, 9, 12))
+>b3 : boolean
 >true : boolean
->b4 : { t1: boolean; t2: string; }, Symbol(b4, Decl(destructuringVariableDeclaration1ES6.ts, 9, 23))
->temp : { t1: boolean; t2: string; }, Symbol(temp, Decl(destructuringVariableDeclaration1ES6.ts, 8, 3))
+>b4 : { t1: boolean; t2: string; }
+>temp : { t1: boolean; t2: string; }
 >[3, false, { t1: false, t2: "hello" }] : [number, boolean, { t1: boolean; t2: string; }]
 >3 : number
 >false : boolean
 >{ t1: false, t2: "hello" } : { t1: boolean; t2: string; }
->t1 : boolean, Symbol(t1, Decl(destructuringVariableDeclaration1ES6.ts, 9, 49))
+>t1 : boolean
 >false : boolean
->t2 : string, Symbol(t2, Decl(destructuringVariableDeclaration1ES6.ts, 9, 60))
+>t2 : string
 >"hello" : string
 
 var [b5 = 3, b6 = true, b7 = temp] = [undefined, undefined, undefined];
->b5 : any, Symbol(b5, Decl(destructuringVariableDeclaration1ES6.ts, 10, 5))
+>b5 : any
 >3 : number
->b6 : any, Symbol(b6, Decl(destructuringVariableDeclaration1ES6.ts, 10, 12))
+>b6 : any
 >true : boolean
->b7 : any, Symbol(b7, Decl(destructuringVariableDeclaration1ES6.ts, 10, 23))
->temp : { t1: boolean; t2: string; }, Symbol(temp, Decl(destructuringVariableDeclaration1ES6.ts, 8, 3))
+>b7 : any
+>temp : { t1: boolean; t2: string; }
 >[undefined, undefined, undefined] : [undefined, undefined, undefined]
->undefined : undefined, Symbol(undefined)
->undefined : undefined, Symbol(undefined)
->undefined : undefined, Symbol(undefined)
+>undefined : undefined
+>undefined : undefined
+>undefined : undefined
 
 // The type T associated with a binding element is determined as follows:
 //      If the binding element is a rest element, T is an array type with
 //          an element type E, where E is the type of the numeric index signature of S.
 var [...c1] = [1,2,3]; 
->c1 : number[], Symbol(c1, Decl(destructuringVariableDeclaration1ES6.ts, 15, 5))
+>c1 : number[]
 >[1,2,3] : number[]
 >1 : number
 >2 : number
 >3 : number
 
 var [...c2] = [1,2,3, "string"]; 
->c2 : (string | number)[], Symbol(c2, Decl(destructuringVariableDeclaration1ES6.ts, 16, 5))
+>c2 : (string | number)[]
 >[1,2,3, "string"] : (string | number)[]
 >1 : number
 >2 : number
@@ -96,8 +96,8 @@ var [...c2] = [1,2,3, "string"];
 //          	Let N be the zero-based index of the binding element in the array binding pattern.
 // 	            If S has a property with the numerical name N, T is the type of that property.
 var [d1,d2] = [1,"string"]	
->d1 : number, Symbol(d1, Decl(destructuringVariableDeclaration1ES6.ts, 22, 5))
->d2 : string, Symbol(d2, Decl(destructuringVariableDeclaration1ES6.ts, 22, 8))
+>d1 : number
+>d2 : string
 >[1,"string"] : [number, string]
 >1 : number
 >"string" : string
@@ -106,60 +106,60 @@ var [d1,d2] = [1,"string"]
 //      Otherwise, if S is a tuple- like type (section 3.3.3):
 //              Otherwise, if S has a numeric index signature, T is the type of the numeric index signature.
 var temp1 = [true, false, true]
->temp1 : boolean[], Symbol(temp1, Decl(destructuringVariableDeclaration1ES6.ts, 27, 3))
+>temp1 : boolean[]
 >[true, false, true] : boolean[]
 >true : boolean
 >false : boolean
 >true : boolean
 
 var [d3, d4] = [1, "string", ...temp1];
->d3 : string | number | boolean, Symbol(d3, Decl(destructuringVariableDeclaration1ES6.ts, 28, 5))
->d4 : string | number | boolean, Symbol(d4, Decl(destructuringVariableDeclaration1ES6.ts, 28, 8))
+>d3 : string | number | boolean
+>d4 : string | number | boolean
 >[1, "string", ...temp1] : (string | number | boolean)[]
 >1 : number
 >"string" : string
 >...temp1 : boolean
->temp1 : boolean[], Symbol(temp1, Decl(destructuringVariableDeclaration1ES6.ts, 27, 3))
+>temp1 : boolean[]
 
 //  Combining both forms of destructuring,
 var {e: [e1, e2, e3 = { b1: 1000, b4: 200 }]} = { e: [1, 2, { b1: 4, b4: 0 }] }; 
 >e : any
->e1 : number, Symbol(e1, Decl(destructuringVariableDeclaration1ES6.ts, 31, 9))
->e2 : number, Symbol(e2, Decl(destructuringVariableDeclaration1ES6.ts, 31, 12))
->e3 : { b1: number; b4: number; }, Symbol(e3, Decl(destructuringVariableDeclaration1ES6.ts, 31, 16))
+>e1 : number
+>e2 : number
+>e3 : { b1: number; b4: number; }
 >{ b1: 1000, b4: 200 } : { b1: number; b4: number; }
->b1 : number, Symbol(b1, Decl(destructuringVariableDeclaration1ES6.ts, 31, 23))
+>b1 : number
 >1000 : number
->b4 : number, Symbol(b4, Decl(destructuringVariableDeclaration1ES6.ts, 31, 33))
+>b4 : number
 >200 : number
 >{ e: [1, 2, { b1: 4, b4: 0 }] } : { e: [number, number, { b1: number; b4: number; }]; }
->e : [number, number, { b1: number; b4: number; }], Symbol(e, Decl(destructuringVariableDeclaration1ES6.ts, 31, 49))
+>e : [number, number, { b1: number; b4: number; }]
 >[1, 2, { b1: 4, b4: 0 }] : [number, number, { b1: number; b4: number; }]
 >1 : number
 >2 : number
 >{ b1: 4, b4: 0 } : { b1: number; b4: number; }
->b1 : number, Symbol(b1, Decl(destructuringVariableDeclaration1ES6.ts, 31, 61))
+>b1 : number
 >4 : number
->b4 : number, Symbol(b4, Decl(destructuringVariableDeclaration1ES6.ts, 31, 68))
+>b4 : number
 >0 : number
 
 var {f: [f1, f2, { f3: f4, f5 }, , ]} = { f: [1, 2, { f3: 4, f5: 0 }] };
 >f : any
->f1 : number, Symbol(f1, Decl(destructuringVariableDeclaration1ES6.ts, 32, 9))
->f2 : number, Symbol(f2, Decl(destructuringVariableDeclaration1ES6.ts, 32, 12))
+>f1 : number
+>f2 : number
 >f3 : any
->f4 : number, Symbol(f4, Decl(destructuringVariableDeclaration1ES6.ts, 32, 18))
->f5 : number, Symbol(f5, Decl(destructuringVariableDeclaration1ES6.ts, 32, 26))
+>f4 : number
+>f5 : number
 > : undefined
 >{ f: [1, 2, { f3: 4, f5: 0 }] } : { f: [number, number, { f3: number; f5: number; }]; }
->f : [number, number, { f3: number; f5: number; }], Symbol(f, Decl(destructuringVariableDeclaration1ES6.ts, 32, 41))
+>f : [number, number, { f3: number; f5: number; }]
 >[1, 2, { f3: 4, f5: 0 }] : [number, number, { f3: number; f5: number; }]
 >1 : number
 >2 : number
 >{ f3: 4, f5: 0 } : { f3: number; f5: number; }
->f3 : number, Symbol(f3, Decl(destructuringVariableDeclaration1ES6.ts, 32, 53))
+>f3 : number
 >4 : number
->f5 : number, Symbol(f5, Decl(destructuringVariableDeclaration1ES6.ts, 32, 60))
+>f5 : number
 >0 : number
 
 // When a destructuring variable declaration, binding property, or binding element specifies
@@ -167,32 +167,32 @@ var {f: [f1, f2, { f3: f4, f5 }, , ]} = { f: [1, 2, { f3: 4, f5: 0 }] };
 // to the widened form of the type associated with the destructuring variable declaration, binding property, or binding element.
 var {g: {g1 = [undefined, null]}}: { g: { g1: any[] } } = { g: { g1: [1, 2] } };
 >g : any
->g1 : any[], Symbol(g1, Decl(destructuringVariableDeclaration1ES6.ts, 37, 9))
+>g1 : any[]
 >[undefined, null] : null[]
->undefined : undefined, Symbol(undefined)
+>undefined : undefined
 >null : null
->g : { g1: any[]; }, Symbol(g, Decl(destructuringVariableDeclaration1ES6.ts, 37, 36))
->g1 : any[], Symbol(g1, Decl(destructuringVariableDeclaration1ES6.ts, 37, 41))
+>g : { g1: any[]; }
+>g1 : any[]
 >{ g: { g1: [1, 2] } } : { g: { g1: number[]; }; }
->g : { g1: number[]; }, Symbol(g, Decl(destructuringVariableDeclaration1ES6.ts, 37, 59))
+>g : { g1: number[]; }
 >{ g1: [1, 2] } : { g1: number[]; }
->g1 : number[], Symbol(g1, Decl(destructuringVariableDeclaration1ES6.ts, 37, 64))
+>g1 : number[]
 >[1, 2] : number[]
 >1 : number
 >2 : number
 
 var {h: {h1 = [undefined, null]}}: { h: { h1: number[] } } = { h: { h1: [1, 2] } };
 >h : any
->h1 : number[], Symbol(h1, Decl(destructuringVariableDeclaration1ES6.ts, 38, 9))
+>h1 : number[]
 >[undefined, null] : null[]
->undefined : undefined, Symbol(undefined)
+>undefined : undefined
 >null : null
->h : { h1: number[]; }, Symbol(h, Decl(destructuringVariableDeclaration1ES6.ts, 38, 36))
->h1 : number[], Symbol(h1, Decl(destructuringVariableDeclaration1ES6.ts, 38, 41))
+>h : { h1: number[]; }
+>h1 : number[]
 >{ h: { h1: [1, 2] } } : { h: { h1: number[]; }; }
->h : { h1: number[]; }, Symbol(h, Decl(destructuringVariableDeclaration1ES6.ts, 38, 62))
+>h : { h1: number[]; }
 >{ h1: [1, 2] } : { h1: number[]; }
->h1 : number[], Symbol(h1, Decl(destructuringVariableDeclaration1ES6.ts, 38, 67))
+>h1 : number[]
 >[1, 2] : number[]
 >1 : number
 >2 : number

tests/baselines/reference/destructuringVariableDeclaration2.js

@@ -35,4 +35,4 @@ var _g = [1, 2, { c3: 4, c5: 0 }], c1 = _g[0], c2 = _g[1], _h = _g[2], c4 = _h.c
 // When a destructuring variable declaration, binding property, or binding element specifies
 // an initializer expression, the type of the initializer expression is required to be assignable
 // to the widened form of the type associated with the destructuring variable declaration, binding property, or binding element.
-var _j = ({ d: { d1: [1, 2] } }).d.d1, d1 = _j === void 0 ? ["string", null] : _j; // Error
+var _j = { d: { d1: [1, 2] } }.d.d1, d1 = _j === void 0 ? ["string", null] : _j; // Error