ChakraCore/test/es6/destructuring.js

//-------------------------------------------------------------------------------------------------------
// Copyright (C) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
//-------------------------------------------------------------------------------------------------------

WScript.LoadScriptFile("..\\UnitTestFramework\\UnitTestFramework.js");

var tests = [
  {
    name: "Basic parsing and early errors",
    body: function () {
      // No initializer
      assert.throws(function () { eval("var [];"); },    SyntaxError, "Destructured var array declaration must have at least one identifier reference",   "Destructuring declarations must have an initializer");
      assert.throws(function () { eval("let [];"); },    SyntaxError, "Destructured let array declaration must have at least one identifier reference",   "Destructuring declarations must have an initializer");
      assert.throws(function () { eval("const [];"); },  SyntaxError, "Destructured const array declaration must have at least one identifier reference", "Destructuring declarations must have an initializer");
      assert.throws(function () { eval("var [a];"); },   SyntaxError, "Destructured var array declaration must have an initializer",                      "Destructuring declarations must have an initializer");
      assert.throws(function () { eval("let [a];"); },   SyntaxError, "Destructured let array declaration must have an initializer",                      "Destructuring declarations must have an initializer");
      assert.throws(function () { eval("const [a];"); }, SyntaxError, "Destructured const array declaration must have an initializer",                    "Destructuring declarations must have an initializer");

      // No identifiers
      assert.doesNotThrow(function () { eval("var [] = [];"); },   "Destructured var array declaration with no identifiers does not throw");
      assert.doesNotThrow(function () { eval("let [] = [];"); },   "Destructured let array declaration with no identifiers does not throw");
      assert.doesNotThrow(function () { eval("const [] = [];"); }, "Destructured const array declaration with no identifiers does not throw");
      assert.doesNotThrow(function () { eval("[] = [];"); },       "Destructured array assignment with no identifiers does not throw");

      // Mismatched expression and initializer length
      assert.doesNotThrow(function () { eval("var [a] = [];"); },    "Destructured var array declaration with an empty initializer array does not throw");
      assert.doesNotThrow(function () { eval("let [a] = [];"); },    "Destructured let array declaration with an empty initializer array does not throw");
      assert.doesNotThrow(function () { eval("const [a] = [];"); },  "Destructured const array declaration with an empty initializer array does not throw");
      assert.doesNotThrow(function () { eval("var a; [a] = [];"); }, "Destructured var array assignment with an empty initializer array does not throw");
      assert.doesNotThrow(function () { eval("let a; [a] = [];"); }, "Destructured let array assignment with an empty initializer array does not throw");

      assert.doesNotThrow(function () { eval("var [a] = [1];"); },    "Destructured var array declaration with matching initializer array size does not throw");
      assert.doesNotThrow(function () { eval("let [a] = [2];"); },    "Destructured let array declaration with matching initializer array size does not throw");
      assert.doesNotThrow(function () { eval("const [a] = [1];"); },  "Destructured const array declaration with matching initializer array size does not throw");
      assert.doesNotThrow(function () { eval("var a; [a] = [1];"); }, "Destructured var array assignment with matching initializer array size does not throw");
      assert.doesNotThrow(function () { eval("let a; [a] = [2];"); }, "Destructured let array assignment with matching initializer array size does not throw");

      assert.doesNotThrow(function () { eval("var [a, b] = [1];"); },       "Destructured var array declaration with smaller initializer array size does not throw");
      assert.doesNotThrow(function () { eval("let [a, b] = [1];"); },       "Destructured let array declaration with smaller initializer array size does not throw");
      assert.doesNotThrow(function () { eval("const [a, b] = [1];"); },     "Destructured const array declaration with smaller initializer array size does not throw");
      assert.doesNotThrow(function () { eval("var a, b; [a, b] = [1];"); }, "Destructured var array assignment with smaller initializer array size does not throw");
      assert.doesNotThrow(function () { eval("let a, b; [a, b] = [1];"); }, "Destructured let array assignment with smaller initializer array size does not throw");

      assert.doesNotThrow(function () { eval("var [a] = [1, 2];"); },       "Destructured var array declaration with larger initializer array size does not throw");
      assert.doesNotThrow(function () { eval("let [a] = [1, 2];"); },       "Destructured let array declaration with larger initializer array size does not throw");
      assert.doesNotThrow(function () { eval("const [a] = [1, 2];"); },     "Destructured const array declaration with larger initializer array size does not throw");
      assert.doesNotThrow(function () { eval("var a; [a] = [1, 2];"); },    "Destructured var array assignment with larger initializer array size does not throw");
      assert.doesNotThrow(function () { eval("let a; [a] = [1, 2];"); },    "Destructured let array assignment with larger initializer array size does not throw");

      // Disallowed operators
      assert.throws(function () { eval("var [a--] = [];"); },        SyntaxError, "Destructured var array declaration with an operator throws",   "Unexpected operator in destructuring expression");
      assert.throws(function () { eval("let [a--] = [];"); },        SyntaxError, "Destructured let array declaration with an operator throws",   "Unexpected operator in destructuring expression");
      assert.throws(function () { eval("const [a--] = [];"); },      SyntaxError, "Destructured const array declaration with an operator throws", "Unexpected operator in destructuring expression");
      assert.throws(function () { eval("var [a + 1] = [];"); },      SyntaxError, "Destructured var array declaration with an operator throws",   "Unexpected operator in destructuring expression");
      assert.throws(function () { eval("let [a + 1] = [];"); },      SyntaxError, "Destructured let array declaration with an operator throws",   "Unexpected operator in destructuring expression");
      assert.throws(function () { eval("const [a + 1] = [];"); },    SyntaxError, "Destructured const array declaration with an operator throws", "Unexpected operator in destructuring expression");
      assert.throws(function () { eval("var [++a] = [];"); },        SyntaxError, "Destructured var array declaration with an operator throws",   "Unexpected operator in destructuring expression");
      assert.throws(function () { eval("let [++a] = [];"); },        SyntaxError, "Destructured let array declaration with an operator throws",   "Unexpected operator in destructuring expression");
      assert.throws(function () { eval("const [++a] = [];"); },      SyntaxError, "Destructured const array declaration with an operator throws", "Unexpected operator in destructuring expression");
      assert.throws(function () { eval("var a; [a--] = [];"); },     SyntaxError, "Destructured var array assignment with an operator throws",    "Unexpected operator in destructuring expression");
      assert.throws(function () { eval("let a; [a--] = [];"); },     SyntaxError, "Destructured let array assignment with an operator throws",    "Unexpected operator in destructuring expression");
      assert.throws(function () { eval("var a; [a + 1] = [];"); },   SyntaxError, "Destructured var array assignment with an operator throws",    "Unexpected operator in destructuring expression");
      assert.throws(function () { eval("let a; [a + 1] = [];"); },   SyntaxError, "Destructured let array assignment with an operator throws",    "Unexpected operator in destructuring expression");
      assert.throws(function () { eval("var a; [++a] = [];"); },     SyntaxError, "Destructured var array assignment with an operator throws",    "Unexpected operator in destructuring expression");
      assert.throws(function () { eval("let a; [++a] = [];"); },     SyntaxError, "Destructured let array assignment with an operator throws",    "Unexpected operator in destructuring expression");
      assert.doesNotThrow(function () { eval("var a = [1], i = 0; [a[i++]] = [];"); }, "Destructured var array assignment operators inside an identifier reference does not throw");
      assert.doesNotThrow(function () { eval("let a = [1], i = 0; [a[i++]] = [];"); }, "Destructured var array assignment operators inside an identifier reference does not throw");
      assert.doesNotThrow(function () { eval("var a = [1], i = 0; [a[(() => 1 + i)()]] = [];"); }, "Destructured var array assignment operators inside an identifier reference does not throw");
      assert.doesNotThrow(function () { eval("let a = [1], i = 0; [a[(() => 1 + i)()]] = [];"); }, "Destructured var array assignment operators inside an identifier reference does not throw");

      // Missing values
      assert.doesNotThrow(function () { eval("var [,] = [];"); },   "Destructured var array declaration with no identifiers and missing values does not throw");
      assert.doesNotThrow(function () { eval("let [,] = [];"); },   "Destructured let array declaration with no identifiers and missing values does not throw");
      assert.doesNotThrow(function () { eval("const [,] = [];"); }, "Destructured const array declaration with no identifiers and missing values does not throw");
      assert.doesNotThrow(function () { eval("[,] = [];"); },       "Destructured array assignment with no identifiers and missing values does not throw");

      assert.doesNotThrow(function () { eval("var [a,] = [];"); },    "Destructured var array declaration ending with a missing value does not throw");
      assert.doesNotThrow(function () { eval("let [a,] = [];"); },    "Destructured let array declaration ending with a missing value does not throw");
      assert.doesNotThrow(function () { eval("const [a,] = [];"); },  "Destructured const array declaration ending with a missing value does not throw");
      assert.doesNotThrow(function () { eval("var a; [a,] = [];"); }, "Destructured var array assignment ending with a missing value does not throw");
      assert.doesNotThrow(function () { eval("let a; [a,] = [];"); }, "Destructured let array assignment ending with a missing value does not throw");

      assert.doesNotThrow(function () { eval("var [a,,b] = [];"); },       "Destructured var array declaration with some missing values does not throw");
      assert.doesNotThrow(function () { eval("let [a,,b] = [];"); },       "Destructured let array declaration with some missing values does not throw");
      assert.doesNotThrow(function () { eval("const [a,,b] = [];"); },     "Destructured const array declaration with some missing values does not throw");
      assert.doesNotThrow(function () { eval("var a, b; [a,,b] = [];"); }, "Destructured var array assignment with some missing values does not throw");
      assert.doesNotThrow(function () { eval("let a, b; [a,,b] = [];"); }, "Destructured let array assignment with some missing values does not throw");

      assert.doesNotThrow(function () { eval("var [,,a] = [];"); },    "Destructured var array declaration beginning with missing values does not throw");
      assert.doesNotThrow(function () { eval("let [,,a] = [];"); },    "Destructured let array declaration beginning with missing values does not throw");
      assert.doesNotThrow(function () { eval("const [,,a] = [];"); },  "Destructured const array declaration beginning with missing values does not throw");
      assert.doesNotThrow(function () { eval("var a; [,,a] = [];"); }, "Destructured var array assignment beginning with missing values does not throw");
      assert.doesNotThrow(function () { eval("let a; [,,a] = [];"); }, "Destructured let array assignment beginning with missing values does not throw");

      assert.doesNotThrow(function () { eval("var [a] = [,,];"); },    "Destructured var array declaration with an initializer containing missing values does not throw");
      assert.doesNotThrow(function () { eval("let [a] = [,,];"); },    "Destructured let array declaration with an initializer containing missing values does not throw");
      assert.doesNotThrow(function () { eval("const [a] = [,,];"); },  "Destructured const array declaration with an initializer containing missing values does not throw");
      assert.doesNotThrow(function () { eval("var a; [a] = [,,];"); }, "Destructured var array assignment with an initializer containing missing values does not throw");
      assert.doesNotThrow(function () { eval("let a; [a] = [,,];"); }, "Destructured let array assignment with an initializer containing missing values does not throw");

      // Non-identifiers
      assert.throws(function () { eval("var [1] = [];"); },         SyntaxError, "Destructured var array declaration with no identifier references throws",                  "Destructuring expressions can only have identifier references");
      assert.throws(function () { eval("let [1] = [];"); },         SyntaxError, "Destructured let array declaration with no identifier references throws",                  "Destructuring expressions can only have identifier references");
      assert.throws(function () { eval("const [1] = [];"); },       SyntaxError, "Destructured const array declaration with no identifier references throws",                "Destructuring expressions can only have identifier references");
      assert.throws(function () { eval("[1] = [];"); },             SyntaxError, "Destructured array assignment with no identifier references throws",                       "Destructuring expressions can only have identifier references");
      assert.throws(function () { eval("var [1, a] = [];"); },      SyntaxError, "Destructured var array declaration with valid and invalid identifier references throws",   "Destructuring expressions can only have identifier references");
      assert.throws(function () { eval("let [1, a] = [];"); },      SyntaxError, "Destructured let array declaration with valid and invalid identifier references throws",   "Destructuring expressions can only have identifier references");
      assert.throws(function () { eval("const [1, a] = [];"); },    SyntaxError, "Destructured const array declaration with valid and invalid identifier references throws", "Destructuring expressions can only have identifier references");
      assert.throws(function () { eval("var a; [1, a] = [];"); },   SyntaxError, "Destructured var array assignment with valid and invalid identifier references throws",    "Destructuring expressions can only have identifier references");
      assert.throws(function () { eval("let a; [1, a] = [];"); },   SyntaxError, "Destructured let array assignment with valid and invalid identifier references throws",    "Destructuring expressions can only have identifier references");

      // Rest parameter
      assert.doesNotThrow(function () { eval("var [...a] = [];"); },    "Destructured var array declaration with a single rest parameter does not throw");
      assert.doesNotThrow(function () { eval("let [...a] = [];"); },    "Destructured let array declaration with a single rest parameter does not throw");
      assert.doesNotThrow(function () { eval("const [...a] = [];"); },  "Destructured const array declaration with a single rest parameter does not throw");
      assert.doesNotThrow(function () { eval("var a; [...a] = [];"); }, "Destructured var array assignment with a single rest parameter does not throw");
      assert.doesNotThrow(function () { eval("let a; [...a] = [];"); }, "Destructured let array assignment with a single rest parameter does not throw");

      assert.throws(function () { eval("var [...a, ...b] = [];"); },         SyntaxError, "Destructured var array declaration with multiple rest parameters throws",   "Destructuring rest variables must be in the last position of the expression");
      assert.throws(function () { eval("let [...a, ...b] = [];"); },         SyntaxError, "Destructured let array declaration with multiple rest parameters throws",   "Destructuring rest variables must be in the last position of the expression");
      assert.throws(function () { eval("const [...a, ...b] = [];"); },       SyntaxError, "Destructured const array declaration with multiple rest parameters throws", "Destructuring rest variables must be in the last position of the expression");
      assert.throws(function () { eval("var a, b; [...a, ...b] = [];"); },   SyntaxError, "Destructured var array assignment with multiple rest parameters throws",    "Destructuring rest variables must be in the last position of the expression");
      assert.throws(function () { eval("let a, b; [...a, ...b] = [];"); },   SyntaxError, "Destructured let array assignment with multiple rest parameters throws",    "Destructuring rest variables must be in the last position of the expression");

      assert.throws(function () { eval("var [...a, b] = [];"); },         SyntaxError, "Destructured var array declaration with rest parameter in non-last position throws",   "Destructuring rest variables must be in the last position of the expression");
      assert.throws(function () { eval("let [...a, b] = [];"); },         SyntaxError, "Destructured let array declaration with rest parameter in non-last position throws",   "Destructuring rest variables must be in the last position of the expression");
      assert.throws(function () { eval("const [...a, b] = [];"); },       SyntaxError, "Destructured const array declaration with rest parameter in non-last position throws", "Destructuring rest variables must be in the last position of the expression");
      assert.throws(function () { eval("var a, b; [...a, b] = [];"); },   SyntaxError, "Destructured var array assignment with rest parameter in non-last position throws",    "Destructuring rest variables must be in the last position of the expression");
      assert.throws(function () { eval("let a, b; [...a, b] = [];"); },   SyntaxError, "Destructured let array assignment with rest parameter in non-last position throws",    "Destructuring rest variables must be in the last position of the expression");
      assert.throws(function () { eval("let [...a,] = [];"); },           SyntaxError, "Destructured array declaration has comma after rest parameter throws",                 "Destructuring rest variables must be in the last position of the expression");
      assert.throws(function () { eval("let a; [...a,] = [];"); },        SyntaxError, "Destructured array assignment has comma after rest parameter throws",                  "Destructuring rest variables must be in the last position of the expression");

      // Default values
      assert.doesNotThrow(function () { eval("var [a = 1] = [];"); },    "Destructured var array declaration with all default values does not throw");
      assert.doesNotThrow(function () { eval("let [a = 1] = [];"); },    "Destructured let array declaration with all default values does not throw");
      assert.doesNotThrow(function () { eval("const [a = 1] = [];"); },  "Destructured const array declaration with all default values does not throw");
      assert.doesNotThrow(function () { eval("var a; [a = 1] = [];"); }, "Destructured var array assignment with all default values does not throw");
      assert.doesNotThrow(function () { eval("let a; [a = 1] = [];"); }, "Destructured let array assignment with all default values does not throw");

      assert.doesNotThrow(function () { eval("var [a, b = 1] = [];"); },       "Destructured var array declaration with trailing default values does not throw");
      assert.doesNotThrow(function () { eval("let [a, b = 1] = [];"); },       "Destructured let array declaration with trailing default values does not throw");
      assert.doesNotThrow(function () { eval("const [a, b = 1] = [];"); },     "Destructured const array declaration with trailing default values does not throw");
      assert.doesNotThrow(function () { eval("var a, b; [a, b = 1] = [];"); }, "Destructured var array assignment with trailing default values does not throw");
      assert.doesNotThrow(function () { eval("let a, b; [a, b = 1] = [];"); }, "Destructured let array assignment with trailing default values does not throw");

      assert.doesNotThrow(function () { eval("var [a = 1, b] = [];"); },       "Destructured var array declaration with mixed default values does not throw");
      assert.doesNotThrow(function () { eval("let [a = 1, b] = [];"); },       "Destructured let array declaration with mixed default values does not throw");
      assert.doesNotThrow(function () { eval("const [a = 1, b] = [];"); },     "Destructured const array declaration with mixed default values does not throw");
      assert.doesNotThrow(function () { eval("var a, b; [a = 1, b] = [];"); }, "Destructured var array assignment with mixed default values does not throw");
      assert.doesNotThrow(function () { eval("let a, b; [a = 1, b] = [];"); }, "Destructured let array assignment with mixed default values does not throw");

      // Rest with default
      assert.throws(function () { eval("var [...a = 1] = [];"); },      SyntaxError, "Destructured var array declaration with a rest parameter with a default value throws",   "Unexpected default initializer");
      assert.throws(function () { eval("let [...a = 1] = [];"); },      SyntaxError, "Destructured let array declaration with a rest parameter with a default value throws",   "Unexpected default initializer");
      assert.throws(function () { eval("const [...a = 1] = [];"); },    SyntaxError, "Destructured const array declaration with a rest parameter with a default value throws", "Unexpected default initializer");
      assert.throws(function () { eval("var a; [...a = 1] = [];"); },   SyntaxError, "Destructured var array assignment with a rest parameter with a default value throws",    "The rest parameter cannot have a default initializer.");
      assert.throws(function () { eval("let a; [...a = 1] = [];"); },   SyntaxError, "Destructured let array assignment with a rest parameter with a default value throws",    "The rest parameter cannot have a default initializer.");

      // Nesting
      assert.doesNotThrow(function () { eval("var [[a]] = [[]];"); },    "Destructured var array declaration with nesting does not throw");
      assert.doesNotThrow(function () { eval("let [[a]] = [[]];"); },    "Destructured let array declaration with nesting does not throw");
      assert.doesNotThrow(function () { eval("const [[a]] = [[]];"); },  "Destructured const array declaration with nesting does not throw");
      assert.doesNotThrow(function () { eval("var a; [[a]] = [[]];"); }, "Destructured var array assignment with nesting does not throw");
      assert.doesNotThrow(function () { eval("let a; [[a]] = [[]];"); }, "Destructured let array assignment with nesting does not throw");

      assert.doesNotThrow(function () { eval("var [a, [b]] = [1, []];"); },       "Destructured var array declaration with some nesting does not throw");
      assert.doesNotThrow(function () { eval("let [a, [b]] = [1, []];"); },       "Destructured let array declaration with some nesting does not throw");
      assert.doesNotThrow(function () { eval("const [a, [b]] = [1, []];"); },     "Destructured const array declaration with some nesting does not throw");
      assert.doesNotThrow(function () { eval("var a, b; [a, [b]] = [1, []];"); }, "Destructured var array assignment with some nesting does not throw");
      assert.doesNotThrow(function () { eval("let a, b; [a, [b]] = [1, []];"); }, "Destructured let array assignment with some nesting does not throw");

      assert.throws(function () { eval("var [((a)] = [];"); },    SyntaxError, "Destructured var array declaration with a mismatched paren count throws",   "Expected ')'");
      assert.throws(function () { eval("let [((a)] = [];"); },    SyntaxError, "Destructured let array declaration with a mismatched paren count throws",   "Expected ')'");
      assert.throws(function () { eval("const [((a)] = [];"); },  SyntaxError, "Destructured const array declaration with a mismatched paren count throws", "Expected ')'");
      assert.throws(function () { eval("var a; [((a)] = [];"); }, SyntaxError, "Destructured var array assignment with a mismatched paren count throws",    "Expected ')'");
      assert.throws(function () { eval("let a; [((a)] = [];"); }, SyntaxError, "Destructured let array assignment with a mismatched paren count throws",    "Expected ')'");
      assert.throws(function () { eval("var [a)] = [];"); },      SyntaxError, "Destructured var array declaration with a mismatched paren count throws",   "Expected ')'");
      assert.throws(function () { eval("let [a)] = [];"); },      SyntaxError, "Destructured let array declaration with a mismatched paren count throws",   "Expected ')'");
      assert.throws(function () { eval("const [a)] = [];"); },    SyntaxError, "Destructured const array declaration with a mismatched paren count throws", "Expected ')'");
      assert.throws(function () { eval("var a; [a)] = [];"); },   SyntaxError, "Destructured var array assignment with a mismatched paren count throws",    "Expected ']'");
      assert.throws(function () { eval("let a; [a)] = [];"); },   SyntaxError, "Destructured let array assignment with a mismatched paren count throws",    "Expected ']'");
      assert.doesNotThrow(function () { eval("var [((((a)))), b] = [];"); },       "Destructured var array declaration with some nested parens does not throw");
      assert.doesNotThrow(function () { eval("let [((((a)))), b] = [];"); },       "Destructured let array declaration with some nested parens does not throw");
      assert.doesNotThrow(function () { eval("const [((((a)))), b] = [];"); },     "Destructured const array declaration with some nested parens does not throw");
      assert.doesNotThrow(function () { eval("var a, b; [((((a)))), b] = [];"); }, "Destructured var array assignment with some nested parens does not throw");
      assert.doesNotThrow(function () { eval("let a, b; [((((a)))), b] = [];"); }, "Destructured let array assignment with some nested parens does not throw");

      assert.doesNotThrow(function () { eval("var [[[...a]]] = [[[]]];"); },    "Destructured var array declaration with nested rest parameter does not throw");
      assert.doesNotThrow(function () { eval("let [[[...a]]] = [[[]]];"); },    "Destructured let array declaration with nested rest parameter does not throw");
      assert.doesNotThrow(function () { eval("const [[[...a]]] = [[[]]];"); },  "Destructured const array declaration with nested rest parameter does not throw");
      assert.doesNotThrow(function () { eval("var a; [[[...a]]] = [[[]]];"); }, "Destructured var array assignment with nested rest parameter does not throw");
      assert.doesNotThrow(function () { eval("let a; [[[...a]]] = [[[]]];"); }, "Destructured let array assignment with nested rest parameter does not throw");

      assert.doesNotThrow(function () { eval("var [[...a], ...b] = [[],];"); },       "Destructured var array declaration with valid nested rest parameters does not throw");
      assert.doesNotThrow(function () { eval("let [[...a], ...b] = [[],];"); },       "Destructured let array declaration with valid nested rest parameters does not throw");
      assert.doesNotThrow(function () { eval("const [[...a], ...b] = [[],];"); },     "Destructured const array declaration with valid nested rest parameters does not throw");
      assert.doesNotThrow(function () { eval("var a, b; [[...a], ...b] = [[],];"); }, "Destructured var array assignment with valid nested rest parameters does not throw");
      assert.doesNotThrow(function () { eval("let a, b; [[...a], ...b] = [[],];"); }, "Destructured let array assignment with valid nested rest parameters does not throw");

      assert.doesNotThrow(function () { eval("var [[(a)], ((((((([b])))))))] = [[],[]];"); },       "Destructured var array declaration with valid mixed paren and array nesting does not throw");
      assert.doesNotThrow(function () { eval("let [[(a)], ((((((([b])))))))] = [[],[]];"); },       "Destructured let array declaration with valid mixed paren and array nesting does not throw");
      assert.doesNotThrow(function () { eval("const [[(a)], ((((((([b])))))))] = [[],[]];"); },     "Destructured const array declaration with valid mixed paren and array nesting does not throw");
      assert.doesNotThrow(function () { eval("var a, b; [[(a)], ((((((([b])))))))] = [[],[]];"); }, "Destructured var array assignment with valid mixed paren and array nesting does not throw");
      assert.doesNotThrow(function () { eval("let a, b; [[(a)], ((((((([b])))))))] = [[],[]];"); }, "Destructured let array assignment with valid mixed paren and array nesting does not throw");

      // Redeclarations
      assert.doesNotThrow(function () { eval("var [a, a] = [];"); },    "Destructured var array declaration with a repeated identifier reference does not throw");
      assert.throws(function () { eval("let [a, a] = [];"); },   SyntaxError, "Destructured let array declaration with a repeated identifier reference throws", "Let/Const redeclaration");
      assert.throws(function () { eval("const [a, a] = [];"); }, SyntaxError, "Destructured const array declaration with a repeated identifier reference throws", "Let/Const redeclaration");
      assert.doesNotThrow(function () { eval("var a; [a, a] = [];"); }, "Destructured var array assignment with a repeated identifier reference does not throw");
      assert.doesNotThrow(function () { eval("let a; [a, a] = [];"); }, "Destructured let array assignment with a repeated identifier reference does not throw");

      // Identifier property references
      assert.doesNotThrow(function () { eval("var a = {}; [a.x] = [];"); },      "Destructured var array assignment with an identifier property reference does not throw");
      assert.doesNotThrow(function () { eval("let a = {}; [a.x] = [];"); },      "Destructured let array assignment with an identifier property reference does not throw");
      assert.doesNotThrow(function () { eval("var a = {}; [a[\"x\"]] = [];"); }, "Destructured var array assignment with an identifier property reference does not throw");
      assert.doesNotThrow(function () { eval("let a = {}; [a[\"x\"]] = [];"); }, "Destructured let array assignment with an identifier property reference does not throw");

      // Call expression property references
      assert.throws(function () { eval("function foo() { return {}; }; var [foo()] = [];"); },       SyntaxError,    "Destructured var array declaration with a call expression throws",                      "Syntax error");
      assert.throws(function () { eval("function foo() { return {}; }; let [foo()] = [];"); },       SyntaxError,    "Destructured let array declaration with a call expression throws",                      "Let/Const redeclaration");
      assert.throws(function () { eval("function foo() { return {}; }; const [foo()] = [];"); },     SyntaxError,    "Destructured const array declaration with a call expression throws",                    "Let/Const redeclaration");
      assert.throws(function () { eval("function foo() { return {}; }; [foo()] = [];"); },           SyntaxError,    "Destructured array assignment with a call expression throws",                           "Invalid destructuring assignment target");
      assert.throws(function () { eval("function foo() { return {}; }; var [foo().x] = [];"); },     SyntaxError,    "Destructured var array declaration with a call expression property reference throws",   "Syntax error");
      assert.throws(function () { eval("function foo() { return {}; }; let [foo().x] = [];"); },     SyntaxError,    "Destructured let array declaration with a call expression property reference throws",   "Let/Const redeclaration");
      assert.throws(function () { eval("function foo() { return {}; }; const [foo().x] = [];"); },   SyntaxError,    "Destructured const array declaration with a call expression property reference throws", "Let/Const redeclaration");
      assert.doesNotThrow(function () { eval("function foo() { return {}; }; [foo().x] = [];"); },      "Destructured array assignment with super a property reference does not throw");
      assert.doesNotThrow(function () { eval("function foo() { return {}; }; [foo()[\"x\"]] = [];"); }, "Destructured array assignment with a call expression property reference does not throw");

      // Super property references
      assert.throws(function () { eval("class foo { method() { var [super()] = []; } }"); },     SyntaxError, "Destructured var array declaration with a super call throws",                         "The use of a keyword for an identifier is invalid");
      assert.throws(function () { eval("class foo { method() { let [super()] = []; } }"); },     SyntaxError, "Destructured let array declaration with a super call throws",                         "The use of a keyword for an identifier is invalid");
      assert.throws(function () { eval("class foo { method() { const [super()] = []; } }"); },   SyntaxError, "Destructured const array declaration with a super call throws",                       "The use of a keyword for an identifier is invalid");
      assert.throws(function () { eval("class foo { method() { [super()] = []; } }"); },         SyntaxError, "Destructured array assignment with a super call throws",                              "Invalid use of the 'super' keyword");
      assert.throws(function () { eval("class foo { method() { var [super.x] = []; } }"); },     SyntaxError, "Destructured var array declaration with a super property reference throws",           "The use of a keyword for an identifier is invalid");
      assert.throws(function () { eval("class foo { method() { let [super.x] = []; } }"); },     SyntaxError, "Destructured let array declaration with a super property reference does not throw",   "The use of a keyword for an identifier is invalid");
      assert.throws(function () { eval("class foo { method() { const [super.x] = []; } }"); },   SyntaxError, "Destructured const array declaration with a super property reference does not throw", "The use of a keyword for an identifier is invalid");
      assert.doesNotThrow(function () { eval("class foo { method() { [super.x] = []; } }"); },      "Destructured var array assignment with super a property reference does not throw");
      assert.doesNotThrow(function () { eval("class foo { method() { [super[\"x\"]] = []; } }"); }, "Destructured array assignment with a super property reference does not throw");

      // Destructured array expressions used in other constructs
      assert.doesNotThrow(function () { eval("var a; `${[a] = [1]}`"); }, "Destructured assignment does not throw inside a string template");

      // OS 597319: Parens before a default value should not throw
      assert.doesNotThrow(function () { eval("[((((vrh190 )))) = 5184] = []"); }, "Destructured array assignment with parens before a default expression should not throw");
    }
  },
  {
    name: "Array destructuring basic functionality",
    body : function () {
      // Single assignments & undefined
      {
        let a1; [a1] = [1];
        let     [a2] = [1];

        assert.areEqual(a1, a2, "Destructured array declaration and assignment assigning single values match");
        assert.areEqual(a1, 1,  "Destructured array assignment assigns single value correctly");
        assert.areEqual(a2, 1,  "Destructured array declaration assigns single value correctly");
      }
      {
        let a1; [a1] = [];
        let     [a2] = [];

        assert.areEqual(a1, a2,        "Destructured array declaration and assignment assigning an empty array match");
        assert.areEqual(a1, undefined, "Destructured array assignment assigning an empty array results in undefined");
        assert.areEqual(a2, undefined, "Destructured array declaration assigning an empty array results in undefined");

        let a3; [a3] = [,1];
        let     [a4] = [,1];

        assert.areEqual(a3, a4,        "Destructured array declaration and assignment assigning an array with missing values match");
        assert.areEqual(a3, undefined, "Destructured array assignment assigning an array with missing values results in undefined");
        assert.areEqual(a4, undefined, "Destructured array declaration assigning an array with missing values in undefined");
      }

      // Multiple assignments
      {
        let a1, b1, c1, d1, e1;
        [a1, b1, c1, d1, e1]     = [1, 2, 3, 4, 5];

        let [a2, b2, c2, d2, e2] = [1, 2, 3, 4, 5];

        assert.areEqual([a1, b1, c1, d1, e1], [a2, b2, c2, d2, e2], "Destructured array assignment and declaration assigning multiple values match");
        assert.areEqual([1, 2, 3, 4, 5],      [a1, b1, c1, d1, e1], "Destructured array assignment assigns multiple values correctly");
        assert.areEqual([1, 2, 3, 4, 5],      [a2, b2, c2, d2, e2], "Destructured array declaration assigns multiple values correctly");
      }
      {
        let a1, b1, c1, d1, e1;
        [a1, b1, c1, d1, e1]     = [1, 2, 3];

        let [a2, b2, c2, d2, e2] = [1, 2, 3];

        assert.areEqual([a1, b1, c1, d1, e1],            [a2, b2, c2, d2, e2], "Destructured array assignment and declaration assigning a smaller array match");
        assert.areEqual([1, 2, 3, undefined, undefined], [a1, b1, c1, d1, e1], "Destructured array assignment assigns a smaller array correctly");
        assert.areEqual([1, 2, 3, undefined, undefined], [a2, b2, c2, d2, e2], "Destructured array declaration assigns a smaller array correctly");
      }
      {
        let a1, b1, c1, d1, e1;
        [a1, b1, c1, d1, e1]     = [1, , 3, , 5];

        let [a2, b2, c2, d2, e2] = [1, , 3, , 5];

        assert.areEqual([a1, b1, c1, d1, e1],            [a2, b2, c2, d2, e2], "Destructured array assignment and declaration assigning an array with some missing values match");
        assert.areEqual([1, undefined, 3, undefined, 5], [a1, b1, c1, d1, e1], "Destructured array assignment assigns an array with some missing values correctly");
        assert.areEqual([1, undefined, 3, undefined, 5], [a2, b2, c2, d2, e2], "Destructured array declaration assigns an array with some missing values correctly");
      }

      // Rest
      {
        let rest1;
        [...rest1]     = [1, 2, 3, 4, 5];

        let [...rest2] = [1, 2, 3, 4, 5];

        assert.areEqual(rest1,           rest2, "Destructured array assignment and declaration using only a rest parameter match");
        assert.areEqual([1, 2, 3, 4, 5], rest1, "Destructured array assignment uses only a rest parameter correctly");
        assert.areEqual([1, 2, 3, 4, 5], rest2, "Destructured array declaration uses only a rest parameter correctly");
      }
      {
        let a1, b1, c1, d1, e1;
        [a1, b1, c1, ...rest1]     = [1, 2, 3, 4, 5];

        let [a2, b2, c2, ...rest2] = [1, 2, 3, 4, 5];

        assert.areEqual([a1, b1, c1, rest1], [a2, b2, c2, rest2], "Destructured array assignment and declaration using a rest parameter match");
        assert.areEqual([1, 2, 3, [4, 5]],   [a1, b1, c1, rest1], "Destructured array assignment uses a rest parameter correctly");
        assert.areEqual([1, 2, 3, [4, 5]],   [a2, b2, c2, rest2], "Destructured array declaration uses a rest parameter correctly");

        let a3, b3, c3, d3, e3;
        [a3, b3, c3, ...rest3]     = [1, 2, 3];

        let [a4, b4, c4, ...rest4] = [1, 2, 3];

        assert.areEqual([a3, b3, c3, rest3], [a4, b4, c4, rest4], "Destructured array assignment and declaration using a rest parameter and a smaller array match");
        assert.areEqual([1, 2, 3, []],       [a3, b3, c3, rest3], "Destructured array assignment uses a rest parameter and a smaller array correctly");
        assert.areEqual([1, 2, 3, []],       [a4, b4, c4, rest4], "Destructured array declaration uses a rest parameter and a smaller array correctly");
      }
      {
        let a1, b1;
        [[...a1], ...b1]     = [[1, 2, 3, 4], 5, 6, 7, 8];

        let [[...a2], ...b2] = [[1, 2, 3, 4], 5, 6, 7, 8];

        assert.areEqual([a1, b1], [a2, b2],                     "Destructured array assignment and declaration with nested rest parameters match");
        assert.areEqual([a1, b1], [[1, 2, 3, 4], [5, 6, 7, 8]], "Destructured array assignment uses nested rest parameters correctly");
        assert.areEqual([a2, b2], [[1, 2, 3, 4], [5, 6, 7, 8]], "Destructured array declaration uses nested rest parameters correctly");
      }

      // Default values
      {
        let a1, b1, c1, d1, e1;
        [a1 = 1, b1 = 2, c1 = 3, d1 = 4, e1 = 5]     = [];

        let [a2 = 1, b2 = 2, c2 = 3, d2 = 4, e2 = 5] = [];

        assert.areEqual([a1, b1, c1, d1, e1], [a2, b2, c2, d2, e2], "Destructured array assignment and declaration with default values assigning an empty array match");
        assert.areEqual([1, 2, 3, 4, 5],      [a1, b1, c1, d1, e1], "Destructured array assignment assigns an array with default values assigning an empty array correctly");
        assert.areEqual([1, 2, 3, 4, 5],      [a2, b2, c2, d2, e2], "Destructured array declaration assigns an array with default values assigning an empty array correctly");
      }
      {
        let a1, b1, c1, d1, e1;
        [a1 = 1, b1 = 2, c1 = 3, d1 = 4, e1 = 5]     = [5, , 3, 2, ];

        let [a2 = 1, b2 = 2, c2 = 3, d2 = 4, e2 = 5] = [5, , 3, 2, ];

        assert.areEqual([a1, b1, c1, d1, e1], [a2, b2, c2, d2, e2], "Destructured array assignment and declaration assigning an array with some missing values match");
        assert.areEqual([5, 2, 3, 2, 5],      [a1, b1, c1, d1, e1], "Destructured array assignment assigns an array with some missing values correctly");
        assert.areEqual([5, 2, 3, 2, 5],      [a2, b2, c2, d2, e2], "Destructured array declaration assigns an array with some missing values correctly");
      }

      // Identifier references
      {
        let a    = {};
        [a.x]    = [10];
        assert.areEqual(10,   a.x,        "Destructured array with an object property assignment works correctly");
        [a["x"]] = [20];
        assert.areEqual(20,   a["x"],     "Destructured array with an object index assignment works correctly");

        var obj = { x: 10 };
        function foo() { return obj };

        [foo().x] = [20];
        assert.areEqual(20,   foo().x,    "Destructured array with a call result property assignment works correctly");

        [foo()["x"]] = [30];
        assert.areEqual(30,   foo()["x"], "Destructured array with a call result index assignment works correctly");

        [...foo().x] = [20];
        assert.areEqual([20], foo().x,    "Destructured array with a call result rest element works correctly");

        [...foo()["x"]] = [30];
        assert.areEqual([30], foo()["x"], "Destructured array with a call result rest element works correctly");

        class base {
          methodProp()      { return {}; }
          methodIndex()     { return {}; }
          methodRestProp()  { return {}; }
          methodRestIndex() { return {}; }
          get x()           { return this._x; }
          set x(v)          { this._x = v; }
        };
        class extended extends base {
          methodProp()      { return [super.x] = [10, 20, 30]; }
          methodIndex()     { return [super["x"]] = [40, 50, 60]; }
          methodRestProp()  { return [...super.x] = [10, 20, 30]; }
          methodRestIndex() { return [...super.x] = [40, 50, 60]; }
          getValue()        { return super.x;}
        };

        let c = new extended();
        assert.areEqual(undefined,    c.getValue(), "Super property before destructured assignment is undefined");

        c.methodProp();
        assert.areEqual(10,           c.getValue(), "Super property after destructured super property assignment");

        c.methodIndex();
        assert.areEqual(40,           c.getValue(), "Super property after destructured super index assignment");

        c.methodRestProp();
        assert.areEqual([10, 20, 30], c.getValue(), "Super property after destructured super property assignment");

        c.methodRestIndex();
        assert.areEqual([40, 50, 60], c.getValue(), "Super property after destructured super index assignment");
      }

      // Nesting
      {
        let a1; [[a1]] = [[1]];
        let     [[a2]] = [[1]];

        assert.areEqual(a1, a2, "Destructured array declaration and assignment assigning single values match");
        assert.areEqual(a1, 1,  "Destructured array assignment assigns single value correctly");
        assert.areEqual(a2, 1,  "Destructured array declaration assigns single value correctly");
      }
      {
        let a1, b1, c1, d1, e1;
        [[a1, b1], c1, [d1, [e1]]]     = [[1, 2], 3, [4, [5]]];

        let [[a2, b2], c2, [d2, [e2]]] = [[1, 2], 3, [4, [5]]];

        assert.areEqual([a1, b1, c1, d1, e1], [a2, b2, c2, d2, e2], "Destructured array assignment and declaration assigning multiple values match");
        assert.areEqual([1, 2, 3, 4, 5],      [a1, b1, c1, d1, e1], "Destructured array assignment assigns multiple values correctly");
        assert.areEqual([1, 2, 3, 4, 5],      [a2, b2, c2, d2, e2], "Destructured array declaration assigns multiple values correctly");
      }
      {
        let a1; [[a1, b1] = [1, 2]] = [];
        let     [[a2, b2] = [1, 2]] = [];

        assert.areEqual([a1, b1], [a2, b2], "Destructured array declaration and assignment using nested values match");
        assert.areEqual([1, 2],   [a1, b1], "Destructured array assignment assigns nested values correctly");
        assert.areEqual([1, 2],   [a2, b2], "Destructured array declaration assigns nested values correctly");
      }
      {
        let a1; [[[a1] = [1], [[b1]] = [[2]]] = [, undefined]] = [undefined, ];
        let     [[[a2] = [1], [[b2]] = [[2]]] = [, undefined]] = [undefined, ];

        assert.areEqual([a1, b1], [a2, b2], "Destructured array declaration and assignment using nested default values match");
        assert.areEqual([1, 2],   [a1, b1], "Destructured array assignment assigns nested default values correctly");
        assert.areEqual([1, 2],   [a2, b2], "Destructured array declaration assigns nested default values correctly");
      }

      // Other iterators
      {
        let a1; [a1, b1, c1, d1, ...rest1] = "testing";
        let [a2, b2, c2, d2, ...rest2]     = "testing";

        assert.areEqual([a1, b1, c1, d1, rest1],               [a2, b2, c2, d2, rest2], "Destructured array declaration and assignment using nested values match");
        assert.areEqual(["t", "e", "s", "t", ["i", "n", "g"]], [a1, b1, c1, d1, rest1], "Destructured array assignment assigns nested values correctly");
        assert.areEqual(["t", "e", "s", "t", ["i", "n", "g"]], [a2, b2, c2, d2, rest2], "Destructured array declaration assigns nested values correctly");
      }
      {
        let map = new Map();

        map.set(1, 6);
        map.set(2, 7);
        map.set(3, 8);
        map.set(4, 9);
        map.set(5, 10);

        let a1; [a1, b1, c1, d1, ...rest1] = map.entries();
        let [a2, b2, c2, d2, ...rest2]     = map.entries();

        assert.areEqual([a1, b1, c1, d1, rest1],                     [a2, b2, c2, d2, rest2], "Destructured array declaration and assignment using nested values match");
        assert.areEqual([[1, 6], [2, 7], [3, 8], [4, 9], [[5, 10]]], [a1, b1, c1, d1, rest1], "Destructured array assignment assigns nested values correctly");
        assert.areEqual([[1, 6], [2, 7], [3, 8], [4, 9], [[5, 10]]], [a2, b2, c2, d2, rest2], "Destructured array declaration assigns nested values correctly");
      }
      {
        let getIteratorCalledCount = 0;
        let nextCalledCount = 0;
        let doneCalledCount = 0;
        let valueCalledCount = 0;

        let simpleIterator = {
            [Symbol.iterator]: function () {
            ++getIteratorCalledCount;
            return {
              i: 0,
              next: function () {
                ++nextCalledCount;
                var that = this;
                return {
                  get done() {
                    ++doneCalledCount;
                    return that.i == 1;
                  },
                  get value() {
                    ++valueCalledCount;
                    return that.i++;
                  }
                };
              }
            };
          }
        };

        let [a, b, c] = simpleIterator;
        assert.areEqual(1, getIteratorCalledCount, "GetIterator is called once per iterator");
        assert.areEqual(3, nextCalledCount,        "'.next()' is called once per destructuring reference");
        assert.areEqual(3, doneCalledCount,        "'done' is read once per destructuring reference");
        assert.areEqual(1, valueCalledCount,       "'value' is read once per .next() call until done is true");

        [getIteratorCalledCount, nextCalledCount, doneCalledCount, valueCalledCount] = [0, 0, 0, 0];

        let [...rest] = simpleIterator;
        assert.areEqual(1, getIteratorCalledCount, "GetIterator is called once per iterator");
        assert.areEqual(2, nextCalledCount,        "'.next()' is called until done is true when filling a rest element");
        assert.areEqual(2, doneCalledCount,        "'done' is read until it is true");
        assert.areEqual(1, valueCalledCount,       "'value' is read once for each .next() call until done is true");

        [getIteratorCalledCount, nextCalledCount, doneCalledCount, valueCalledCount] = [0, 0, 0, 0];

        [a, b, c, ...rest] = simpleIterator;
        assert.areEqual(1, getIteratorCalledCount, "GetIterator is called once per iterator");
        assert.areEqual(4, nextCalledCount,        "'.next()' is called once per destructuring reference");
        assert.areEqual(4, doneCalledCount,        "'done' is read once per destructuring reference");
        assert.areEqual(1, valueCalledCount,       "'value' is read once per .next() call until done is true");
      }

      // Runtime type errors
      assert.throws(function () { eval("let [a] = 1;") },       TypeError, "Non-object used as an iterator in a declaration throws",        "Object doesn't support property or method 'Symbol.iterator'");
      assert.throws(function () { eval("let a; [a] = 1;") },    TypeError, "Non-object used as an iterator an assignment throws"   ,        "Object doesn't support property or method 'Symbol.iterator'");
      assert.throws(function () { eval("let [[a]] = [];") },    TypeError, "Nested non-object used as an iterator in a declaration throws", "Unable to get property 'Symbol.iterator' of undefined or null reference");
      assert.throws(function () { eval("let a; [[a]] = [];") }, TypeError, "Nested non-object used as an iterator an assignment throws",    "Unable to get property 'Symbol.iterator' of undefined or null reference");

      // Array destructuring in various contexts
      {
        let a, b, c;
        function foo(x = [a, b = 2, ...c] = [1,,3,4,5,6,7]) {
          assert.areEqual([1, 2, [3,4,5,6,7]], [a, b, c], "Destructuring array assignment works correctly inside a default parameter expression");
          assert.areEqual([1,,3,4,5,6,7],      x,         "Destructuring array assignment evaluates to RHS in a default parameter expression");
        }
        foo();

        `${[a = 5, b, ...c] = [, 1, 3, 5, 7, 9]}`;
        assert.areEqual([5, 1, [3, 5, 7, 9]], [a, b, c], "Destructuring array assignment inside a string template works correctly");

        (() => [a,, b, c] = [1, 2, 3])();
        assert.areEqual([1, 3, undefined], [a, b, c], "Destructuring array assignment inside a lambda expression works correctly");
      }

          // nested destructuring
          {
        let [[a]=[1]] = [[2]];
                assert.areEqual(a, 2, "Nested destructuring - value is present");

                [[a]=[1]] = [[]];
                assert.areEqual(a, undefined, "Nested destructuring - value is present but undefined");

                [[a]=[1]] = [];
                assert.areEqual(a, 1, "Nested destructuring - value is not present - use default");

                [[a]=1] = [[]];
                assert.areEqual(a, undefined, "Nested destructuring - value is present - default is incorrect - does not have @@iterator");
          }

       // Bug OSG : 4533495
       {
         function foo() {
            for(var [i, j, k] in { qux: 1 }) {
                return i === "q" && j === "u" && k === "x";
            }
        }
        assert.isTrue(foo(), "Array destructuring pattern on for..in is initialized correctly");
      }
      
      {
         let obj1 = {};
         obj1[Symbol.iterator] = function () {
            return {
                next: function() {
                    assert.fail("next function should not be called");
                }
            };
         };
         
         // Empty slot should not call next on the iterator.
         var [] = obj1;
      }

      {
         let obj1 = {};
         obj1[Symbol.iterator] = function () {
            return {
                next: function() {
                    this.counter++;
                    if (this.counter > 1)
                    {
                        assert.fail("next function should not be called for the second time");
                    }
                    return {value : undefined, done: false};
                },
                counter : 0
            };
         };
         
         // Second empty slot should not call next on the iterator.
         var [,] = obj1;
      }

    }
  }
];

testRunner.runTests(tests, { verbose: WScript.Arguments[0] != "summary" });