ChakraCore/test/es6/destructuring_params.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 destructuring syntax as params",
    body: function () {
      assert.doesNotThrow(function () { eval("function foo({x:x}) {}"); }, "Object destructuring pattern as a formal is valid syntax");
      assert.doesNotThrow(function () { eval("function foo({x}) {}"); },   "Object destructuring pattern (shorthand) as a formal is valid syntax");
      assert.doesNotThrow(function () { eval("function foo([x]) {}"); },   "Array destructuring pattern as a formal is valid syntax");

      assert.doesNotThrow(function () { eval("function foo({x:x}, y) {}"); },   "Object destructuring pattern as a first formal is valid syntax");
      assert.doesNotThrow(function () { eval("function foo([x], y) {}"); },   "Array destructuring pattern as a first formal is valid syntax");

      assert.doesNotThrow(function () { eval("function foo(y, {x:x}) {}"); },   "Object destructuring pattern as a second formal is valid syntax");
      assert.doesNotThrow(function () { eval("function foo(y, [x]) {}"); },   "Array destructuring pattern as a second formal is valid syntax");


      assert.doesNotThrow(function () { eval("function foo({}) {}"); },   "Object destructuring pattern (with empty syntax) as a formal is valid syntax");
      assert.doesNotThrow(function () { eval("function foo([]) {}"); },   "Array destructuring pattern (with empty syntax) as a formal is valid syntax");
      assert.doesNotThrow(function () { eval("function foo([,]) {}"); },   "Array destructuring pattern (with empty syntax and comma) as a formal is valid syntax");
    }
  },
  {
    name: "Destructuring syntax as params - invalid syntax",
    body: function () {
      assert.throws(function () { eval("function foo({,}) {}"); }, SyntaxError,  "Object destructuring pattern as a formal with empty names is not valid syntax", "Expected identifier, string or number");
      assert.throws(function () { eval("function foo(({})) {}"); }, SyntaxError,  "Object destructuring pattern as a formal surrounded with parens is not valid syntax", "Expected identifier");
      assert.throws(function () { eval("function foo(([])) {}"); }, SyntaxError,  "Array destructuring pattern as a formal surrounded with parens is not valid syntax", "Expected identifier");
      assert.throws(function () { eval("function foo([x}) {}"); }, SyntaxError,  "Array destructuring pattern without right bracket is not valid syntax", "Unexpected operator in destructuring expression");
      assert.throws(function () { eval("function foo({x:abc+1}) {}"); }, SyntaxError,  "Object destructuring pattern with operator is not valid syntax", "Unexpected operator in destructuring expression");
      assert.throws(function () { eval("function foo({x:abc.d}) {}"); }, SyntaxError,  "Object destructuring pattern as a formal with property reference is not valid syntax", "Syntax error");
      assert.throws(function () { eval("function foo([abc.d]) {}"); }, SyntaxError,  "Array destructuring pattern as a formal with property reference is not valid syntax", "Syntax error");
      assert.throws(function () { eval("function foo([super]) {}"); }, SyntaxError,  "Array destructuring pattern as a formal identifier as super is not valid syntax", "The use of a keyword for an identifier is invalid");
      assert.throws(function () { eval("function foo({x:super}) {}"); },  SyntaxError, "Object destructuring pattern as a formal identifier as super is not valid syntax", "The use of a keyword for an identifier is invalid");
      assert.throws(function () { eval("function foo({x:super()}) {}"); }, SyntaxError,  "Object destructuring pattern as a formal identifier as super call is not valid syntax", "The use of a keyword for an identifier is invalid");
      assert.throws(function () { eval("function foo([super()]) {}"); }, SyntaxError,  "Array destructuring pattern as a formal identifier as super call is not valid syntax", "The use of a keyword for an identifier is invalid");
    }
  },
  {
    name: "Destructuring syntax as params - Multiple and mixed patterns",
    body: function () {
      assert.doesNotThrow(function () { eval("function foo({x:x}, {y:y}, {z:z}) {}"); },   "Three params as object pattern is valid syntax");
      assert.doesNotThrow(function () { eval("function foo([x], [y], [z]) {}"); },   "Three params as array pattern is valid syntax");

      assert.doesNotThrow(function () { eval("function foo({x1:x1, x2:x2, x3:x3}, {y1:y1, y1:y2}) {}"); },   "Two params as object pattern, and each pattern has more than one matching name is valid syntax");
      assert.doesNotThrow(function () { eval("function foo([x1, x2, x3], [y1, y2, y3]) {}"); },   "Two params as array pattern, and each pattern has more than one matching name is valid syntax");

      assert.doesNotThrow(function () { eval("function foo({x1:x1}, [y1]) {}"); },   "Two params with first object pattern and second array pattern is valid syntax");
      assert.doesNotThrow(function () { eval("function foo([x1], {y1:y1}) {}"); },   "Two params with first array pattern and second object pattern is valid syntax");

      assert.doesNotThrow(function () { eval("function foo(x1, {x2, x3}, [x4, x5], x6) {}"); }, "Multiple params with mixed of binding identifier and binding pattern is valid syntax");

      assert.doesNotThrow(function () { eval("function foo({x1:[y1]}) {}"); },   "Object destructuring pattern nesting array pattern as a formal is valid syntax");
      assert.doesNotThrow(function () { eval("function foo([x1, {y1:y1}]) {}"); },   "Array destructuring pattern nesting object pattern as a formal is valid syntax");
    }
  },
  {
    name: "Destructuring syntax as params - class/function expression/function expression with names/lambda",
    body: function () {
      assert.doesNotThrow(function () { eval("({x}) => x;"); },   "Object destructuring pattern as a formal on lambda is valid syntax");
      assert.doesNotThrow(function () { eval("([x]) => x;"); },   "Array destructuring pattern as a formal on lambda is valid syntax");

      assert.doesNotThrow(function () { eval("class foo { constructor({x1}){} }"); },   "Object destructuring pattern as a formal on constructor of class is valid syntax");
      assert.doesNotThrow(function () { eval("class foo { constructor([x1]){} }"); },   "Array destructuring pattern as a formal on constructor of class is valid syntax");
      assert.doesNotThrow(function () { eval("class foo { method({x1}){ }; set prop({x1}){} }"); },   "Object destructuring pattern on method and setter of class is valid syntax");
      assert.doesNotThrow(function () { eval("class foo { method([x1]){ }; set prop([x1]){} }"); },   "Array destructuring pattern on method and setter of class is valid syntax");

      assert.doesNotThrow(function () { eval("let foo = function ({x1}, [x2]){};"); },   "Destructuring patterns as formals on function expression is valid syntax");
      assert.doesNotThrow(function () { eval("(function({x1}, [x2]){})"); },   "Destructuring patterns as formals on anonymous function is valid syntax");

      assert.doesNotThrow(function () { eval("let bar = function foo({x1}, [x2]){};"); },   "Destructuring patterns as formals on named function expression is valid syntax");
      assert.doesNotThrow(function () { eval("new Function('{x}', '[y]', 'return x + y');"); },   "Destructuring patterns as formals on function constructor is valid syntax");
      assert.doesNotThrow(function () { eval("let obj = { foo({x}) {}, set prop([x]) {} }"); },   "Destructuring pattern as a formal on functions of object literal is valid syntax");
    }
  },
  {
    name: "Destructuring syntax as params - Initializer",
    body: function () {
      assert.doesNotThrow(function () { eval("function foo({x:x = 10}) {}"); },   "One param as object destructuring pattern with initializer is valid syntax");
      assert.doesNotThrow(function () { eval("function foo([x = 20]) {}"); },   "One param as array destructuring pattern with initializer is valid syntax");

      assert.doesNotThrow(function () { eval("function foo({x1:x1 = 1}, {y1:y1 = 2}) {}"); },   "Two params as object destructuring pattern with initializer is valid syntax");
      assert.doesNotThrow(function () { eval("function foo([x1 = 1], [y1 = 2]) {}"); },   "Two params as array destructuring pattern with initializer is valid syntax");

      assert.doesNotThrow(function () { eval("function foo({x1:x1 = 1, x2:x2 = 2, x3:x3 = 3}) {}"); },   "One param as object destructuring pattern has three names with initializer is valid syntax");
      assert.doesNotThrow(function () { eval("function foo([x1 = 1, x2 = 2, x3 = 3]) {}"); },   "One param as array destructuring pattern has three names with initializer is valid syntax");

      assert.doesNotThrow(function () { eval("function foo({x1:x1 = 1}, [y1 = 2]) {}"); },   "First param as object pattern and second as array pattern with initializer is valid syntax");
      assert.doesNotThrow(function () { eval("function foo([x1 = 1], {y1:y1 = 2}) {}"); },   "First param as array pattern and second as object pattern with initializer is valid syntax");

      assert.doesNotThrow(function () { eval("function foo({x:x} = {x:1}) {}"); }, "Object destructuring pattern has default value is valid syntax");
      assert.doesNotThrow(function () { eval("function foo([x] = [1]) {}"); },  "Array destructuring pattern has default value is valid syntax");

      assert.doesNotThrow(function () { eval("function foo({x:x = 1} = {x:2}) {}"); }, "Object destructuring pattern has default and identifier has initializer is valid syntax");
      assert.doesNotThrow(function () { eval("function foo([x = 1] = [2]) {}"); }, "Array destructuring pattern has default and identifier has initializer is valid syntax");

      assert.doesNotThrow(function () { eval("function foo({x1:[y1 = 1]}) {}"); },   "Object destructuring pattern nesting array pattern which has initializer is valid syntax");
      assert.doesNotThrow(function () { eval("function foo([x1, {y1:y1 = 1}]) {}"); },   "Array destructuring pattern nesting object pattern which has initializer is valid syntax");

      assert.doesNotThrow(function () { eval("function foo({x1:[y1 = 1] = [2]} = {x1:[3]}) {}"); },   "Object destructuring pattern has default and nesting array pattern which has initializer is valid syntax");
      assert.doesNotThrow(function () { eval("function foo([{y1:y1 = 1} = {y1:2}] = [{y1:3}]) {}"); },   "Array destructuring pattern has default and nesting object pattern which has initializer is valid syntax");
    }
  },
  {
    name: "Destructuring syntax as params - redeclarations",
    body: function () {
      assert.throws(function () { eval("function foo({x:x, x:x}) {}"); },  SyntaxError,  "One formal as object pattern has duplicate binding identifiers is not valid syntax", "Let/Const redeclaration");
      assert.throws(function () { eval("function foo({x:x}, {x:x}) {}"); },  SyntaxError,  "Two formals as object patterns have duplicate binding identifiers is not valid syntax", "Let/Const redeclaration");
      assert.throws(function () { eval("function foo([x, x]) {}"); }, SyntaxError,   "One formal as array pattern has duplicate binding identifiers is not valid syntax", "Let/Const redeclaration");
      assert.throws(function () { eval("function foo([x], [x]) {}"); },  SyntaxError,  "Two formals as array patterns have duplicate binding identifiers is not valid syntax", "Let/Const redeclaration");
      assert.throws(function () { eval("function foo([x], {x:x}) {}"); },  SyntaxError,  "Mixed array and object pattern with duplicate identifiers is not valid syntax", "Let/Const redeclaration");
      assert.throws(function () { eval("function foo([x], x) {}"); },  SyntaxError,  "First formal as array pattern has matching name with the second formal is not valid syntax", "Duplicate formal parameter names not allowed in this context");
      assert.throws(function () { eval("function foo(x, [x]) {}"); },  SyntaxError,  "First normal formal is matching with the second formal which is array pattern is not valid syntax", "Let/Const redeclaration");
      assert.throws(function () { eval("function foo({x:{z:[z1]}}, z1) {}"); },  SyntaxError,  "First formal as nesting object pattern has matching name with the second formal is not valid syntax", "Duplicate formal parameter names not allowed in this context");
      assert.throws(function () { eval("function foo([x]) { let x = 10;}"); },  SyntaxError,  "Object destructuring pattern as a formal is valid syntax", "Let/Const redeclaration");
      assert.doesNotThrow(function () { eval("function foo([x]) { var x = 10;}"); },  "var declared names matching with formal (as array pattern) is valid syntax");
    }
  },
  {
    name: "Destructuring on param - basic functionality",
    body : function () {
            function f1({x:x}) {
                return x;
            }
            let ret = f1({x:1});
            assert.areEqual(ret, 1, "Object pattern as a formal matches with actual param and initializes the identifier correctly");

            function f2([x]) {
                return x;
            }
            ret = f2([2]);
            assert.areEqual(ret, 2,  "Array pattern as a formal matches with actual param and initializes the identifier correctly");

            function f3({x}, [y], z) {
                return x + y + z;
            }
            ret = f3({x:1}, [2], 3);
            assert.areEqual(ret, 6,  "First formal as object pattern and second formal as array pattern should match and initialize identifiers correctly");

            let f4 = function ([x], {y:y}, z) {
                return x + y + z;
            }
            ret = f4([1], {y:2}, 3);
            assert.areEqual(ret, 6,  "First formal as array pattern and second formal as object pattern should match and initialize identifiers correctly");
        }
   },
  {
    name: "Destructuring on param - initializer",
    body : function () {
            function f1({x:x1 = 11}, [x2 = 22]) {
                assert.areEqual(x1, 1, "Identifier from the first pattern has initializer but matches the actual first param and initializes correctly");
                assert.areEqual(x2, 2, "Identifier from the second pattern has initializer byt matches the actual second param and initializes correctly");
            }
            f1({x:1}, [2]);

            function f2({x:x1 = 11}, [x2 = 22]) {
                assert.areEqual(x1, 11, "Identifier from the first pattern gets undefined from the actual first param so initializes with initializer");
                assert.areEqual(x2, 22, "Identifier from the second pattern gets undefined from the actual second param so initializes with initializer");
            }
            f2({}, []);

            (function ({x:x1 = 11} = {x:111}, [x2 = 22] = [222]) {
                assert.areEqual(x1, 111, "First pattern matches with default as the actual first param is undefined");
                assert.areEqual(x2, 222, "Second pattern matches with default as the actual second param is undefined");
            })(undefined, undefined);
        }
   },
  {
    name: "Destructuring on param - functionality on lambda/function expression",
    body : function () {
            (function({x:x1}) {
                assert.areEqual(x1, 1,  "Anonymous function - object pattern as a formal matches with actual param and initializes identifier correctly");
            })({x:1});

            let f1 = ([x1]) => x1 * 2;
            assert.areEqual(f1([2]), 4,  "Lambda - array pattern as a formal matches with actual param and initializes identifier correctly");

            let f2 = ({x:x2}) => x2 * 4;
            assert.areEqual(f2({x:2}), 8,  "Lambda - object pattern as a formal matches with actual param and initializes identifier correctly");

            let f3 = function foo({x:x1}) {
                assert.areEqual(x1, 1,  "Named function expression - object pattern as a formal matches with actual param and initializes identifier correctly");
            }
            f3({x:1});

            let f4 = new Function("{x}", "[y]", "return x + y");
            assert.areEqual(f4({x:1}, [2]), 3,  "Function constructor - patterns as formals match with actual params and initialize identifiers correctly");
        }
   },
  {
    name: "Destructuring on param - captures",
    body : function () {
        function f1({x:x1}) {
            function f1_1() {
                assert.areEqual(x1, 1,  "Identifier from object pattern is captured and initialized correctly");
            }
            f1_1();
        }
        f1({x:1});

        function f2([x1]) {
            function f2_1() {
                assert.areEqual(x1, 2,  "Identifier from array pattern is captured and initialized correctly");
            }
            f2_1();
        }
        f2([2]);

        function f3({x:x1}, [y1], z) {
            (function () {
                x1++;
            })();
            (function () {
                y1++;
            })();
            var k = x1 + y1 + z;
            assert.areEqual(k, 62,  "Identifiers from patterns are captured and initialized correctly");
        }
        f3({x:10}, [20], 30);
     }
   },
  {
    name: "Destructuring on param - capture due to eval",
    body : function () {
        function f1({x:x1}, [x2]) {
            eval('');
            assert.areEqual(x1, 1,  "Function has eval - identifier from the object pattern is initialized correctly");
            assert.areEqual(x2, 2,  "Function has eval - identifier from the array pattern is initialized correctly under eval");
        }
        f1({x:1}, [2]);

        function f2({x:x1}, [x2]) {
            eval('');
            (function () {
                x1;
                x2;
            })();
            assert.areEqual(x1, 3, "Function has eval and inner function - identifier from the object pattern is initialized correctly");
            assert.areEqual(x2, 4, "Function has eval and inner function - identifier from the array pattern is initialized correctly");
        }
        f2({x:3}, [4]);

        function f3({x:x1}, [x2]) {
            (function () {
                eval('');
                assert.areEqual(x1, 5,  "Function's inner function has eval - identifier from the object pattern is initialized correctly");
                assert.areEqual(x2, 6,  "Function's inner function has eval - identifier from the object pattern is initialized correctly");
            })();
        }
        f3({x:5}, [6]);
     }
   },
  {
    name: "Destructuring on param - captures (eval and arguments)",
    body : function () {
        function f1({x:x1}, [x2]) {
            assert.areEqual(arguments[0], {x:1},  "arguments[0] is initialized correctly with first actual argument");
            assert.areEqual(arguments[1], [2],  "arguments[1] is initialized correctly with second actual argument");
        }
        f1({x:1}, [2]);

        function f2({x:x1}, [x2]) {
            (function() {
            })();
            eval('');
            assert.areEqual(arguments[0], {x:1},  "Function has inner function and eval - arguments[0] is initialized correctly with first actual argument");
            assert.areEqual(arguments[1], [2],  "Function has inner function and eval - arguments[1] is initialized correctly with second actual argument");
        }
        f2({x:1}, [2]);

        function f3({x:x1}, [x2]) {
            (function() {
                eval('');
            })();
            assert.areEqual(arguments[0], {x:1},  "Function's inner function has eval - arguments[0] is initialized correctly with first actual argument");
            assert.areEqual(arguments[1], [2],  "Function's inner function has eval - arguments[1] is initialized correctly with second actual argument");
        }
        f3({x:1}, [2]);

        (function({x:x1}, x2) {
            x2 = 3;
            assert.areEqual(arguments[1], 2,  "arguments object is unmapped - changing second formal does not change arguments[1]");
        })({x:1}, 2);

        (function ([x1], x2) {
            arguments[1] = 2;
            assert.areEqual(x2, 1,  "arguments object is unmapped - changing arguments[1] does not change second param");
        })([], 1);

        (function ({x:x1}, x2) {
            x2 = 2;
            (function() {
                eval('');
            })();
            assert.areEqual(arguments[1], 1,  "Function's inner function has eval - arguments object is unmapped - changing second formal does not change arguments[1]");
        })({}, 1);

        (function ([x1], x2) {
            (function() {
                eval('');
            })();
            arguments[1] = 2;
            assert.areEqual(x2, 1,  "Function's inner function has eval - arguments object is unmapped - changing arguments[1] does not change second param");
        })([], 1);

    }
  },
  {
    name: "Destructuring on param - multiple/mixed/nested parameters",
    body : function () {
        (function (x1, {x2, x3}, [x4, x5], x6) {
            var k = x1 + x2 + x3 + x4 + x5 + x6;
            assert.areEqual(k, 21,  "Identifiers under various patterns are matched and initialized correctly");
        })(1, {x2:2, x3:3}, [4, 5], 6);

        (function (x1, {x2, x3}, [x4, x5], x6) {
            var k = x1 + x2 + x3 + x4 + x5 + x6;
            eval('');
            assert.areEqual(k, 21,  "Function has eval - identifiers under various patterns are matched and initialized correctly");
        })(1, {x2:2, x3:3}, [4, 5], 6);

        (function (x1, {x2, x3}, [x4, x5], x6) {
            var k = x1 + x2 + x3 + x4 + x5 + x6;
            (function() {
                eval('');
            });
            assert.areEqual(k, 21,  "Function's inner function has eval - identifiers under various patterns are matched and initialized correctly");
        })(1, {x2:2, x3:3}, [4, 5], 6);

     }
   },
  {
    name: "Destructuring on param - misc",
    body : function () {
        let f1 = function foo(x0, {x:x1}, [x2]) {
            assert.areEqual(x1, 1,  "Function expression with name - identifier from second formal is matched and initialized correctly");
            assert.areEqual(x2, 2,  "Function expression with name - identifier from third formal is matched and initialized correctly");
        }
        f1(0, {x:1}, [2]);

        let f2 = function foo1(x0, {x:x1}, [x2]) {
            eval('');
            assert.areEqual(x1, 1,  "Function expression with name has eval - identifier from second formal is matched and initialized correctly");
            assert.areEqual(x2, 2,  "Function expression with name has eval - identifier from third formal is matched and initialized correctly");
        }
        f2(0, {x:1}, [2]);

        let f3 = function foo2(x0, {x:x1}, [x2]) {
            with(x1) {
                assert.areEqual(x1_1, 1,  "Function expression with name has 'with' - identifier from second formal is matched and initialized correctly");
                assert.areEqual(x2, 2,  "Function expression with name has 'with' - identifier from third formal is matched and initialized correctly");
            }
        }
        f3(0, {x:{x1_1:1}}, [2]);

        let f4 = function foo3(x0, {x:x1}, [x2]) {
            try {
                throw 'abc';
            }
            catch(e) {
                (function () {
                    assert.areEqual(x1, 1,  "Function expression with name has 'try/catch' - identifier from second formal is matched and initialized correctly");
                    assert.areEqual(x2, 2,  "Function expression with name has 'try/catch' - identifier from third formal is matched and initialized correctly");
                })();
            }
        }
        f4(0, {x:1}, [2]);

        let f5 = function foo4(x0, {x:x1}, [x2]) {
            try {
                throw 'abc';
            }
            catch(e) {
                (function () {
                    eval('');
                    assert.areEqual(x1, 1,  "Function expression with name has 'try/catch and eval' - identifier from second formal is matched and initialized correctly");
                    assert.areEqual(x2, 2,  "Function expression with name has 'try/catch and eval' - identifier from third formal is matched and initialized correctly");
                })();
            }
        }
        f5(0, {x:1}, [2]);
     }
   },
  {
    name: "Destructuring on param - class",
    body : function () {
        class Foo {
            add([x1]) {
                this.x1 += x1;
            }

            set prop({x1}) {
                this.x1 = x1;
            }

            get prop() {
                return this.x1;
            }

            static Avg({x1}, [x2], x3) {
                return (x1+x2+x3)/3;
            }
        }

        assert.areEqual(Foo.Avg({x1:3}, [4], 5), 4,  "Class's static function - identifiers from formal patterns are matched and initialized correctly");

        let obj = new Foo();
        obj.prop = {x1:1};
        assert.areEqual(obj.prop, 1, "Class's setter - identifier from the formal object pattern is matched and initialized correctly");

        obj.add([2]);
        assert.areEqual(obj.prop, 3, "Class's method - identifier from the formal array pattern is matched and initialized correctly");
     }
   }
];

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