//-------------------------------------------------------------------------------------------------------
// 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: "Destructuring bug fixes validation",
    body: function () {
      assert.throws(function () { eval("function f1() { var a = 10; [a+2] = []; }; f1();"); }, SyntaxError, "var empty object declaration pattern without an initializer is not valid syntax", "Unexpected operator in destructuring expression");
      assert.throws(function () { eval("function f2() { var a = 10; ({x:a+2} = {x:2}); }; f2();"); }, SyntaxError, "var empty object declaration pattern without an initializer is not valid syntax", "Unexpected operator in destructuring expression");
      assert.throws(function () { eval("function f3() { var a = 10; for ([a+2] in []) { } }; f3();"); }, SyntaxError, "var empty object declaration pattern without an initializer is not valid syntax", "Unexpected operator in destructuring expression");
      assert.doesNotThrow(function () { eval("(function () { var x; for ({x:x}.x of [1,2]) {}; })();"); }, "for..of initializer start with left curly but not a pattern is valid syntax");
      assert.throws(function () { eval("(function () { 'use strict'; [x] = [1]; let x = 2; })();"); }, ReferenceError, "A variable, defined in pattern, is used before its declaration in not valid syntax", "Use before declaration");
      assert.throws(function () { eval("(function () { 'use strict'; let x1 = 1; ({x:x1, y:{y1:y1}} = {x:11, y:{y1:22}}); let y1 = 2; })();"); }, ReferenceError, "A variable, defined in nested pattern, is used before its declaration is not valid syntax", "Use before declaration");
      assert.throws(function () { eval("(function () { 'use strict'; [eval] = []; })();"); }, SyntaxError, "variable name 'eval' defined in array pattern is not valid in strict mode", "Invalid usage of 'eval' in strict mode");
      assert.throws(function () { eval("let a = [a] = [10]"); }, ReferenceError, "A let variable is used in the array pattern in the same statement where it is declared", "Use before declaration");
      assert.throws(function () { eval("let a = {a:a} = {}"); }, ReferenceError, "A let variable is used in object pattern in the same statement where it is declared", "Use before declaration");
      assert.throws(function () { eval("var a = 1; (delete [a] = [2]);"); }, ReferenceError, "Array literal in unary expression should not be converted to array pattern", "Invalid left-hand side in assignment");
      assert.throws(function () { eval("var x, b; for ([x] = [((b) = 1)] of ' ') { }"); }, ReferenceError, "Initializer in for..in is not valid but no assert should be thrown", "Invalid left-hand side in assignment");
      assert.throws(function () { eval("for (let []; ;) { }"); }, SyntaxError, "Native for loop's head has one destructuring pattern without initializer", "Destructuring declarations must have an initializer");
      assert.throws(function () { eval("for (let a = 1, []; ;) { }"); }, SyntaxError, "Native for loop's head has second param as destructuring pattern without initializer", "Destructuring declarations must have an initializer");
      assert.throws(function () { eval("for (let [] = [], a = 1, {}; ;) { }"); }, SyntaxError, "Native for loop's head has third param as object destructuring pattern without initializer", "Destructuring declarations must have an initializer");
      assert.throws(function () { eval("for (let [[a] = []]; ;) { }"); }, SyntaxError, "Native for loop's head as destructuring pattern without initializer", "Destructuring declarations must have an initializer");
      assert.doesNotThrow(function () { eval("for ([]; ;) { break; }"); }, "Native for loop's head is an expression without initializer is valid syntax");
      assert.doesNotThrow(function () { eval("try { y; } catch({}) { }"); }, "Catching exception to empty pattern should not assert and is a valid syntax");
      assert.doesNotThrow(function () { eval("for({} = function (...a) { } in '' ) { }"); }, "Having a function with rest parameter as initializer should not assert and is a valid syntax");
      assert.doesNotThrow(function () { eval("for([] = ((...a) => {}) in '' ) { }"); }, "Having a lambda function with rest parameter as initializer should not assert and is a valid syntax");
      assert.doesNotThrow(function () { eval("[[[] = [function () { }] ] = []]"); }, "Nested array has array pattern which has function expression is a valid syntax");
      assert.doesNotThrow(function () { eval("var a = ({x = 1}) => x;"); }, "Lambda has Object destructuring as parameter which has initializer on shorthand is a valid syntax");
    }
  },
  {
    name: "Destructuring bug fix - function expression under destructuring pattern does not crash",
    body: function () {
      var a = [];
      var b = 2;
      function f() {
        [ a [ function () { }, b ] ] = [2] ;
      }
      f();
    }
  },
  {
    name: "Destructuring bug fix - rest operator in for loop",
    body: function () {
      assert.throws(function () { eval("for (var {a: ...a1} = {}; ; ) { } "); }, SyntaxError, "Native for loop - usage of '...' in object destructuring pattern in not valid", "Unexpected ... operator");
      assert.throws(function () { eval("for (var {a: ...[]} = {}; ; ) { } "); }, SyntaxError, "Native for loop - usage of '...' before an array in object destructuring pattern in not valid", "Unexpected ... operator");
      assert.throws(function () { eval("for (var {a: ...[]} of '' ) { } "); }, SyntaxError, "for.of loop - usage of '...' before an array in object destructuring pattern in not valid", "Unexpected ... operator");
    }
  },
  {
    name: "Destructuring bug fix - call expression instead of reference node",
    body: function () {
      assert.throws(function () { eval("for (var a of {b: foo()} = {}) { }"); }, SyntaxError, "for.of loop has destructuring pattern which has call expression instead of a reference node", "Invalid destructuring assignment target");
      assert.throws(function () { eval("for ([{b: foo()} = {}] of {}) { }"); }, SyntaxError, "for.of loop has destructuring pattern on head which has call expression instead of a reference node", "Invalid destructuring assignment target");
      function foo() {
          return { bar : function() {} };
      }

      assert.throws(function () { eval("for (var a in {b: foo().bar()} = {}) { }"); }, SyntaxError, "for.in loop has destructuring pattern which has linked call expression instead of a reference node", "Invalid destructuring assignment target");
      assert.doesNotThrow(function () { eval("for (var a in {b: foo().bar} = {}) { }"); }, "for.in loop has destructuring pattern which has a reference node is valid syntax", );
    }
  },
  {
    name: "Destructuring bug fix - object coercible",
    body: function () {
      assert.throws(function () { eval("var {} = undefined"); }, TypeError, "Object declaration - RHS cannot be be undefined", "Cannot convert null or undefined to object");
      assert.throws(function () { eval("var {} = null"); }, TypeError, "Object declaration - RHS cannot be be null", "Cannot convert null or undefined to object");
      assert.throws(function () { eval("({} = undefined);"); }, TypeError, "Object assignment pattern - RHS cannot be be undefined", "Cannot convert null or undefined to object");
      assert.throws(function () { eval("([{}] = []);"); }, TypeError, "Object assignment pattern nested with array pattern has evaluated to have undefined as RHS", "Cannot convert null or undefined to object");
      assert.throws(function () { eval("function f({}){}; f();"); }, TypeError, "Object pattern on function - evaluated to have undefined from assignment expression", "Cannot convert null or undefined to object");
      assert.throws(function () { eval("function f({}){}; f(null);"); }, TypeError, "Object pattern on function - evaluated to have null from assignment expression", "Cannot convert null or undefined to object");
    }
  },
  {
    name: "Destructuring bug fix - a variable in body has the same name as param should not throw in the defer parse mode",
    body: function () {
      assert.doesNotThrow(function () { eval("function foo() { function bar([a]) { var a = 1; } }"); }, "variable 'a' is not a re-declaration" );
      assert.doesNotThrow(function () { eval("function foo() { function bar([a], {b, b1}, [c]) { var b1 = 1; } }"); }, "variable 'b1' is not a re-declaration" );
      assert.doesNotThrow(function () { eval("function foo() { ({c}) => { var c = 1; } }"); }, "variable 'c' is not a re-declaration" );
    }
  },
  {
    name: "Destructuring bug fix - assign to const",
    body: function () {
      assert.throws(function () { const c = 10; ({c} = {c:11}); }, TypeError, "Cannot assign to const", "Assignment to const");
      assert.throws(function () { eval("const c = 10; ({c} = {c:11});"); }, TypeError, "Cannot assign to const in eval", "Assignment to const");
      assert.throws(function () { const c = 10; eval("({c} = {c:11});"); }, TypeError, "Cannot assign to const in eval, where const is defined outsdie of eval", "Assignment to const");
    }
  },
  {
    name: "Destructuring bug fix - pattern with rest parameter",
    body: function () {
      assert.doesNotThrow(function () { eval("function foo({a}, ...b) { if (b) { } }; foo({});"); } );
      assert.doesNotThrow(function () { eval("function foo([], ...b) { if (b) { } }; foo([]);"); });
    }
  },
  {
    name: "Object Destructuring with empty identifier/reference",
    body: function () {
      assert.throws(function () { eval("var {x :  } = {};"); }, SyntaxError);
      assert.throws(function () { eval("var {x :  , } = {};"); }, SyntaxError);
      assert.throws(function () { eval("var {x :  , y} = {};"); }, SyntaxError);
      assert.throws(function () { eval("({x : , y} = {});"); }, SyntaxError);
    }
  },
  {
    name: "Destructuring pattern at param has arguments as declaration",
    body: function () {
      assert.doesNotThrow(function () { eval("function foo([arguments]) { arguments; }; foo([1]);"); });
      assert.doesNotThrow(function () { eval("function foo({arguments}) { arguments; }; foo({arguments:1});"); });
      assert.doesNotThrow(function () { eval("function foo({x:{arguments}}) { arguments; }; foo({x:{arguments:1}});"); });
    }
  },
  {
    name: "Destructuring pattern at param has function as default value",
    body: function () {
      assert.doesNotThrow(function () { eval("function foo(x = ({y = function (p) {}} = 'bar')) {}; foo();"); });
      assert.doesNotThrow(function () { eval("var foo = (x = ({y = function (p) {}} = 'bar')) => {}; foo();"); });
    }
  },
  {
    name: "Destructuring empty patterns at param with arguments/eval at function body",
    body: function () {
        (function ({}, {}, {}, {}, {}, a) {
            eval("");
            assert.areEqual(arguments[1].x, 1);
            assert.areEqual(a, 2);
        })({}, {x:1}, {}, {}, {}, 2);
        (function ({}, {}, {}, {}, {}, a) {
            (function () {
                eval("");
            })();
            assert.areEqual(arguments[1].x, 1);
            assert.areEqual(a, 2);
        })({}, {x:1}, {}, {}, {}, 2);
        (function ({}, {}, {}, {}, {}, a) {
            (function () {
                a;
            })();
            eval("");
            assert.areEqual(arguments[1].x, 1);
            assert.areEqual(a, 2);
        })({}, {x:1}, {}, {}, {}, 2);
    }
  },
  {
    name: "Destructuring patterns (multiple identifiers in the pattern) at param with arguments/eval at function body",
    body: function () {
        (function (x1, {x2, x3}, [x4, x5], x6) {
            eval("");
            assert.areEqual(arguments[2], [4, 5]);
        })(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(arguments[2], [4, 5]);
            assert.areEqual(k, 21);
        })(1, {x2:2, x3:3}, [4, 5], 6);

        (function (x1, {x2, x3}, [x4, x5], x6) {
            (function() {
              eval("");  
            });
            assert.areEqual(arguments[3], 6);
            var k = x1 + x2 + x3 + x4 + x5 + x6;
            assert.areEqual(k, 21);
        })(1, {x2:2, x3:3}, [4, 5], 6);

        (function (x1, {x2, x3}, [x4, x5], x6) {
            (function() {
                x3; x5; x6;
            })();
            var k = x1 + x2 + x3 + x4 + x5 + x6;
            assert.areEqual(k, 21);
        })(1, {x2:2, x3:3}, [4, 5], 6);

        (function (x1, {x2, x3}, [x4, x5], x6) {
            (function() {
                x3; x5; x6;
            })();
            var k = x1 + x2 + x3 + x4 + x5 + x6;
            assert.areEqual(arguments[3], 6);
            assert.areEqual(k, 21);
        })(1, {x2:2, x3:3}, [4, 5], 6);
        
        (function (x1, {x2, x3}, [x4, x5], x6) {
            (function() {
                assert.areEqual(x1 + x2 + x3 + x4 + x5 + x6, 21);
            })();
        })(1, {x2:2, x3:3}, [4, 5], 6);

    }
  },
  {
    name: "Destructuring patterns (multiple identifiers in the pattern) at param with lambdas, arguments and eval at function body",
    body: function () {
        (function (x1, {x2, x3}, [x4, x5], x6) {
            (() => {
                assert.areEqual(arguments[2], [4, 5]);
            })();
            eval("");
        })(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(arguments[2], [4, 5]);
                assert.areEqual(k, 21);
            })();
        })(1, {x2:2, x3:3}, [4, 5], 6);
    }
  },
  {
    name: "Destructuring patterns with rest at param with arguments/eval at function body",
    body: function () {
        (function (a, {b},  ...rest) {
            eval("");
            assert.areEqual(b, 2);
            assert.areEqual(arguments[2], 3);
        })(1, {b:2}, 3);

        (function (a, {b},  ...rest) {
            (function () {
                eval("");
            })();
            assert.areEqual(rest, [3]);
            assert.areEqual(arguments[2], 3);
        })(1, {b:2}, 3);

        (function (a, {b}, ...rest) {
            (function () {
                assert.areEqual(b, 2);
                assert.areEqual(rest, [3]);
            })();
            assert.areEqual(rest, [3]);
            assert.areEqual(arguments[2], 3);
        })(1, {b:2}, 3);
    }
  },
  {
    name: "Rest as pattern at param with arguments/eval at function body",
    body: function () {
        (function ([a, b], c, ...{rest1, rest2}) {
            eval("");
            assert.areEqual(rest1, 4);
            assert.areEqual(rest2, 5);
            assert.areEqual(c, 3);
            assert.areEqual(arguments[1], 3);
        })([1, 2], 3, {rest1:4, rest2:5});

        (function ([a, b], c, ...{rest1, rest2}) {
            (function () {
                assert.areEqual(rest1, 4);
                assert.areEqual(rest2, 5);
                assert.areEqual(a+b, 3);
            })();
            eval("");
            assert.areEqual(arguments[0], [1, 2]);
        })([1, 2], 3, {rest1:4, rest2:5});
    }
  },
  {
    name: "Accessing arguments at the params",
    body: function () {
        (function (x1, {x2, x3}, [x4, x5], x6 = arguments[0]) {
            eval("");
            assert.areEqual(arguments[2], [4, 5]);
            assert.areEqual(x6, 1);
        })(1, {x2:2, x3:3}, [4, 5], undefined);

        (function (x1, {x2, x3}, [x4, x5], x6 = arguments[0] = 11) {
            eval("");
            assert.areEqual(arguments[0], 11);
            assert.areEqual(x6, 11);
        })(1, {x2:2, x3:3}, [4, 5], undefined);
    }
  },
  {
    name: "Object destructuring - changing the RHS when emitting",
    body: function () {
        var a = {}, b;
        ({x:a, y:b = 1} = a);
        assert.areEqual(a, undefined);
        assert.areEqual(b, 1);
    }
  },
  {
    name: "Destructuring - Empty object pattern inside call node is a valid syntax",
    body: function () {
        function f() {
            ({} = []).Symbol.interator();
            eval("");
        };
    }
  },
  {
    name: "Destructuring - Place holder slots for pattern are accounted when undeferred.",
    body: function () {
        function foo({a}) {
            function x() {}
            eval('');
        }
        foo({});
        function foo1(...[b]) {
            function x() {}
            eval('');
        }
        foo1([]);
    }
  },
  {
    name: "Destructuring - array pattern at call expression (which causes iterator close)",
    body: function () {
        function foo(x1, x2, x3, x4) {
            assert.areEqual(x1, 'first');
            assert.areEqual(x2, 'second');
            assert.areEqual(x3[0][0], 'third');
            assert.areEqual(x4[0][0][0][0], 'fourth');
        }
        var a1;
        var a2;
        foo([{}] = 'first', 'second', [[a1]] = [['third']], [[[[a2]]]] = [[[['fourth']]]]);
        assert.areEqual(a1, 'third');
        assert.areEqual(a2, 'fourth');
    }
  },
  {
    name: "Destructuring - array patten at call expression - validating the next/return functions are called.",
    body: function () {
        var nextCount = 0;
        var returnCount = 0;
        var iterable = {};
        iterable[Symbol.iterator] = function () {
            return {
                next: function() {
                    nextCount++;
                    return {value : 1, done:false};
                },
                return: function (value) {
                    returnCount++;
                    return {done:true};
                }
            };
        };

        var obj = {
          set prop(val) {
            throw new Error('From setter');
          }
        };
        
        var foo = function () { };
        assert.throws(function () { foo([[obj.prop]] = [iterable]); }, Error, 'pattern at call expression throws and return function is called', 'From setter');
        assert.areEqual(nextCount, 1);
        assert.areEqual(returnCount, 1);
    }
  }
];

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