diff options
Diffstat (limited to 'js/src/tests/test262/language/arguments-object')
269 files changed, 12261 insertions, 0 deletions
diff --git a/js/src/tests/test262/language/arguments-object/10.5-1-s-strict.js b/js/src/tests/test262/language/arguments-object/10.5-1-s-strict.js new file mode 100644 index 0000000000..be251f64ce --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.5-1-s-strict.js @@ -0,0 +1,17 @@ +'use strict'; +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.5-1-s +description: Strict Mode - arguments object is immutable +flags: [onlyStrict] +---*/ + +assert.throws(SyntaxError, function() { + (function fun() { + eval("arguments = 10"); + })(30); +}); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/10.5-1gs-strict.js b/js/src/tests/test262/language/arguments-object/10.5-1gs-strict.js new file mode 100644 index 0000000000..9baf855e42 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.5-1gs-strict.js @@ -0,0 +1,20 @@ +// |reftest| error:SyntaxError +'use strict'; +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.5-1gs +description: Strict Mode - arguments cannot be assigned to in a strict function +negative: + phase: parse + type: SyntaxError +flags: [onlyStrict] +---*/ + +$DONOTEVALUATE(); + + +function f_10_5_1_gs(){ + arguments = 7; +} diff --git a/js/src/tests/test262/language/arguments-object/10.5-7-b-1-s-strict.js b/js/src/tests/test262/language/arguments-object/10.5-7-b-1-s-strict.js new file mode 100644 index 0000000000..17e625081d --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.5-7-b-1-s-strict.js @@ -0,0 +1,15 @@ +'use strict'; +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.5-7-b-1-s +description: Strict Mode - arguments object is immutable in eval'ed functions +flags: [onlyStrict] +---*/ + +assert.throws(SyntaxError, function() { + eval("(function _10_5_7_b_1_fun() { arguments = 10;} ());"); +}); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/10.5-7-b-2-s.js b/js/src/tests/test262/language/arguments-object/10.5-7-b-2-s.js new file mode 100644 index 0000000000..369f0f5712 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.5-7-b-2-s.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.5-7-b-2-s +description: Arguments object index assignment is allowed +---*/ + +function _10_5_7_b_2_fun() { + arguments[7] = 12; + return arguments[7] === 12; +}; + +assert(_10_5_7_b_2_fun(30), '_10_5_7_b_2_fun(30) !== true'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/10.5-7-b-3-s.js b/js/src/tests/test262/language/arguments-object/10.5-7-b-3-s.js new file mode 100644 index 0000000000..f2def5671a --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.5-7-b-3-s.js @@ -0,0 +1,17 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.5-7-b-3-s +description: > + Adding property to the arguments object successful under strict mode +---*/ + +function _10_5_7_b_3_fun() { + arguments[1] = 12; + return arguments[0] === 30 && arguments[1] === 12; +}; + +assert(_10_5_7_b_3_fun(30), '_10_5_7_b_3_fun(30) !== true'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/10.5-7-b-4-s.js b/js/src/tests/test262/language/arguments-object/10.5-7-b-4-s.js new file mode 100644 index 0000000000..3c96f84cae --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.5-7-b-4-s.js @@ -0,0 +1,19 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.5-7-b-4-s +description: > + Deleting property of the arguments object successful under strict mode +---*/ + +function _10_5_7_b_4_fun() { + var _10_5_7_b_4_1 = arguments[0] === 30 && arguments[1] === 12; + delete arguments[1]; + var _10_5_7_b_4_2 = arguments[0] === 30 && typeof arguments[1] === "undefined"; + return _10_5_7_b_4_1 && _10_5_7_b_4_2; +}; + +assert(_10_5_7_b_4_fun(30, 12), '_10_5_7_b_4_fun(30, 12) !== true'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/10.6-10-c-ii-1-s-strict.js b/js/src/tests/test262/language/arguments-object/10.6-10-c-ii-1-s-strict.js new file mode 100644 index 0000000000..75948d07c2 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.6-10-c-ii-1-s-strict.js @@ -0,0 +1,21 @@ +'use strict'; +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.6-10-c-ii-1-s +description: > + arguments[i] remains same after changing actual parameters in + strict mode +flags: [onlyStrict] +---*/ + +function foo(a,b,c) +{ + a = 1; b = 'str'; c = 2.1; + return (arguments[0] === 10 && arguments[1] === 'sss' && arguments[2] === 1); +} + +assert(foo(10, 'sss', 1), 'foo(10, "sss", 1) !== true'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/10.6-10-c-ii-1.js b/js/src/tests/test262/language/arguments-object/10.6-10-c-ii-1.js new file mode 100644 index 0000000000..64fcd7a7bb --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.6-10-c-ii-1.js @@ -0,0 +1,19 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.6-10-c-ii-1 +description: arguments[i] change with actual parameters +flags: [noStrict] +---*/ + +function foo(a,b,c) +{ + a = 1; b = 'str'; c = 2.1; + if(arguments[0] === 1 && arguments[1] === 'str' && arguments[2] === 2.1) + return true; +} + +assert(foo(10,'sss',1), 'foo(10,"sss",1) !== true'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/10.6-10-c-ii-2.js b/js/src/tests/test262/language/arguments-object/10.6-10-c-ii-2.js new file mode 100644 index 0000000000..cb4778a2a3 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.6-10-c-ii-2.js @@ -0,0 +1,19 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.6-10-c-ii-2 +description: arguments[i] map to actual parameter +flags: [noStrict] +---*/ + +function foo(a,b,c) +{ + arguments[0] = 1; arguments[1] = 'str'; arguments[2] = 2.1; + if(1 === a && 'str' === b && 2.1 === c) + return true; +} + +assert(foo(10,'sss',1), 'foo(10,"sss",1) !== true'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/10.6-11-b-1.js b/js/src/tests/test262/language/arguments-object/10.6-11-b-1.js new file mode 100644 index 0000000000..10c84fdda4 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.6-11-b-1.js @@ -0,0 +1,39 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.6-11-b-1 +description: > + Arguments Object has index property '0' as its own property, it + shoulde be writable, enumerable, configurable and does not invoke + the setter defined on Object.prototype[0] (Step 11.b) +includes: [propertyHelper.js] +---*/ + +var data = "data"; +var getFunc = function () { + return data; +}; + +var setFunc = function (value) { + data = value; +}; + +Object.defineProperty(Object.prototype, "0", { + get: getFunc, + set: setFunc, + configurable: true +}); + +var argObj = (function () { return arguments })(1); + +verifyProperty(argObj, "0", { + value: 1, + writable: true, + enumerable: true, + configurable: true, +}); + +assert.sameValue(data, "data", 'data'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/10.6-12-1.js b/js/src/tests/test262/language/arguments-object/10.6-12-1.js new file mode 100644 index 0000000000..0fe86b283e --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.6-12-1.js @@ -0,0 +1,15 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.6-12-1 +description: Accessing callee property of Arguments object is allowed +flags: [noStrict] +---*/ + +function testcase() { + arguments.callee; +} +testcase(); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/10.6-12-2.js b/js/src/tests/test262/language/arguments-object/10.6-12-2.js new file mode 100644 index 0000000000..da0cafe709 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.6-12-2.js @@ -0,0 +1,21 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.6-12-2 +description: arguments.callee has correct attributes +flags: [noStrict] +---*/ + +function testcase() { + var desc = Object.getOwnPropertyDescriptor(arguments,"callee"); + + assert.sameValue(desc.configurable, true, 'desc.configurable'); + assert.sameValue(desc.enumerable, false, 'desc.enumerable'); + assert.sameValue(desc.writable, true, 'desc.writable'); + assert.sameValue(desc.hasOwnProperty('get'), false, 'desc.hasOwnProperty("get")'); + assert.sameValue(desc.hasOwnProperty('set'), false, 'desc.hasOwnProperty("set")'); +} +testcase(); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/10.6-13-a-1.js b/js/src/tests/test262/language/arguments-object/10.6-13-a-1.js new file mode 100644 index 0000000000..f82089d95d --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.6-13-a-1.js @@ -0,0 +1,29 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.6-13-a-1 +description: > + In non-strict mode, arguments object should have its own 'callee' + property defined (Step 13.a) +includes: [propertyHelper.js] +flags: [noStrict] +---*/ + +Object.defineProperty(Object.prototype, "callee", { + value: 1, + writable: false, + configurable: true +}); + +var argObj = (function () { return arguments })(); + +assert.sameValue(typeof argObj.callee, "function"); + +verifyProperty(argObj, "callee", { + writable: true, + enumerable: false, + configurable: true, +}); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/10.6-13-a-2.js b/js/src/tests/test262/language/arguments-object/10.6-13-a-2.js new file mode 100644 index 0000000000..b463923ce0 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.6-13-a-2.js @@ -0,0 +1,33 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.6-13-a-2 +description: A direct call to arguments.callee.caller should work +flags: [noStrict] +features: [caller] +---*/ + +var called = false; + +function test1(flag) { + if (flag!==true) { + test2(); + } else { + called = true; + } +} + +function test2() { + if(arguments.callee.caller===undefined) { + called=true; // Extension not supported - fake it + } else { + arguments.callee.caller(true); + } +} + +test1(); + +assert(called, 'called !== true'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/10.6-13-a-3.js b/js/src/tests/test262/language/arguments-object/10.6-13-a-3.js new file mode 100644 index 0000000000..4ddba446df --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.6-13-a-3.js @@ -0,0 +1,34 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.6-13-a-3 +description: An indirect call to arguments.callee.caller should work +flags: [noStrict] +features: [caller] +---*/ + +var called = false; + +function test1(flag) { + if (flag!==true) { + test2(); + } else { + called = true; + } +} + +function test2() { + if (arguments.callee.caller===undefined) { + called = true; //Extension not supported - fake it + } else { + var explicit = arguments.callee.caller; + explicit(true); + } +} + +test1(); + +assert(called, 'called !== true'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/10.6-13-c-1-s-strict.js b/js/src/tests/test262/language/arguments-object/10.6-13-c-1-s-strict.js new file mode 100644 index 0000000000..b75ab83e8e --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.6-13-c-1-s-strict.js @@ -0,0 +1,18 @@ +'use strict'; +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.6-13-c-1-s +description: > + Accessing callee property of Arguments object throws TypeError in + strict mode +flags: [onlyStrict] +---*/ + + +assert.throws(TypeError, function() { + arguments.callee; +}); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/10.6-13-c-2-s.js b/js/src/tests/test262/language/arguments-object/10.6-13-c-2-s.js new file mode 100644 index 0000000000..c38d8930ca --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.6-13-c-2-s.js @@ -0,0 +1,15 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.6-13-c-2-s +description: arguments.callee is exists +---*/ + +function testcase() { + var desc = Object.getOwnPropertyDescriptor(arguments,"callee"); + assert.notSameValue(desc, undefined); +} +testcase(); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/10.6-13-c-3-s-strict.js b/js/src/tests/test262/language/arguments-object/10.6-13-c-3-s-strict.js new file mode 100644 index 0000000000..b9f851aaf3 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.6-13-c-3-s-strict.js @@ -0,0 +1,23 @@ +'use strict'; +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.6-13-c-3-s +description: arguments.callee is non-configurable in strict mode +flags: [onlyStrict] +---*/ + +function testcase() { + var desc = Object.getOwnPropertyDescriptor(arguments,"callee"); + + assert.sameValue(desc.configurable, false, 'desc.configurable'); + assert.sameValue(desc.enumerable, false, 'desc.enumerable'); + assert.sameValue(desc.hasOwnProperty('value'), false, 'desc.hasOwnProperty("value")'); + assert.sameValue(desc.hasOwnProperty('writable'), false, 'desc.hasOwnProperty("writable")'); + assert.sameValue(desc.hasOwnProperty('get'), true, 'desc.hasOwnProperty("get")'); + assert.sameValue(desc.hasOwnProperty('set'), true, 'desc.hasOwnProperty("set")'); +} +testcase(); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/10.6-14-c-1-s.js b/js/src/tests/test262/language/arguments-object/10.6-14-c-1-s.js new file mode 100644 index 0000000000..279f62eed6 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.6-14-c-1-s.js @@ -0,0 +1,19 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.6-14-c-1-s +description: > + [[Enumerable]] attribute value in 'callee' is false +includes: [propertyHelper.js] +---*/ + +var argObj = function () { + return arguments; +} (); + +verifyProperty(argObj, "callee", { + enumerable: false, +}); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/10.6-14-c-4-s-strict.js b/js/src/tests/test262/language/arguments-object/10.6-14-c-4-s-strict.js new file mode 100644 index 0000000000..2ab3888da7 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.6-14-c-4-s-strict.js @@ -0,0 +1,21 @@ +'use strict'; +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.6-14-c-4-s +description: > + Strict Mode - TypeError is thrown when accessing the [[Set]] + attribute in 'callee' under strict mode +flags: [onlyStrict] +---*/ + +var argObj = function () { + return arguments; +} (); + +assert.throws(TypeError, function() { + argObj.callee = {}; +}); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/10.6-2gs-strict.js b/js/src/tests/test262/language/arguments-object/10.6-2gs-strict.js new file mode 100644 index 0000000000..b358a4a312 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.6-2gs-strict.js @@ -0,0 +1,21 @@ +'use strict'; +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.6-2gs +description: > + Strict Mode - arguments.callee cannot be accessed in a strict + function +flags: [onlyStrict] +---*/ + +function f_10_6_1_gs(){ + return arguments.callee; +} + +assert.throws(TypeError, function() { + f_10_6_1_gs(); +}); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/10.6-5-1.js b/js/src/tests/test262/language/arguments-object/10.6-5-1.js new file mode 100644 index 0000000000..fe83ea562b --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.6-5-1.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.6-5-1 +description: > + [[Prototype]] property of Arguments is set to Object prototype + object +---*/ + +function testcase() { + assert.sameValue(Object.getPrototypeOf(arguments), Object.getPrototypeOf({})); +} +testcase(); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/10.6-6-1.js b/js/src/tests/test262/language/arguments-object/10.6-6-1.js new file mode 100644 index 0000000000..95f43214aa --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.6-6-1.js @@ -0,0 +1,15 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.6-6-1 +description: "'length property of arguments object exists" +---*/ + +function testcase() { + var desc = Object.getOwnPropertyDescriptor(arguments,"length"); + assert.notSameValue(desc, undefined); +} +testcase(); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/10.6-6-2.js b/js/src/tests/test262/language/arguments-object/10.6-6-2.js new file mode 100644 index 0000000000..7360207cec --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.6-6-2.js @@ -0,0 +1,19 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.6-6-2 +description: "'length' property of arguments object has correct attributes" +includes: [propertyHelper.js] +---*/ + +function testcase() { + verifyProperty(arguments, "length", { + writable: true, + enumerable: false, + configurable: true, + }); +} +testcase(); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/10.6-6-3-s.js b/js/src/tests/test262/language/arguments-object/10.6-6-3-s.js new file mode 100644 index 0000000000..57768fe226 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.6-6-3-s.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.6-6-3 +description: > + 'length' property of arguments object for 0 argument function + exists +---*/ + +function testcase() { + assert.sameValue(arguments.length, 0); +} +testcase(); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/10.6-6-3.js b/js/src/tests/test262/language/arguments-object/10.6-6-3.js new file mode 100644 index 0000000000..42a03c7dcf --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.6-6-3.js @@ -0,0 +1,18 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.6-6-3 +description: > + 'length' property of arguments object for 0 argument function + exists +flags: [noStrict] +---*/ + +function testcase() { + var arguments= undefined; + (function () { assert.sameValue(arguments.length, 0); })(); +} +testcase(); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/10.6-6-4-s.js b/js/src/tests/test262/language/arguments-object/10.6-6-4-s.js new file mode 100644 index 0000000000..b8fa0b2ee0 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.6-6-4-s.js @@ -0,0 +1,16 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.6-6-4 +description: > + 'length' property of arguments object for 0 argument function call + is 0 even with formal parameters +---*/ + +function testcase(a,b,c) { + assert.sameValue(arguments.length, 0); +} +testcase(); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/10.6-6-4.js b/js/src/tests/test262/language/arguments-object/10.6-6-4.js new file mode 100644 index 0000000000..c7f8900210 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.6-6-4.js @@ -0,0 +1,18 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.6-6-4 +description: > + 'length' property of arguments object for 0 argument function call + is 0 even with formal parameters +flags: [noStrict] +---*/ + +function testcase() { + var arguments= undefined; + (function (a,b,c) { assert.sameValue(arguments.length, 0); })(); +} +testcase(); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/10.6-7-1.js b/js/src/tests/test262/language/arguments-object/10.6-7-1.js new file mode 100644 index 0000000000..6836c3ca0e --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/10.6-7-1.js @@ -0,0 +1,38 @@ +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.6-7-1 +description: > + Arguments Object has length as its own property and does not + invoke the setter defined on Object.prototype.length (Step 7) +includes: [propertyHelper.js] +---*/ + +var data = "data"; +var getFunc = function () { + return 12; +}; + +var setFunc = function (value) { + data = value; +}; + +Object.defineProperty(Object.prototype, "length", { + get: getFunc, + set: setFunc, + configurable: true +}); + +var argObj = (function () { return arguments })(); + +verifyProperty(argObj, "length", { + value: 0, + writable: true, + enumerable: false, + configurable: true, +}); + +assert.sameValue(data, "data", 'data'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/S10.1.6_A1_T2.js b/js/src/tests/test262/language/arguments-object/S10.1.6_A1_T2.js new file mode 100644 index 0000000000..f7f57505d9 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/S10.1.6_A1_T2.js @@ -0,0 +1,35 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + The activation object is initialised with a property with name arguments + and attributes {DontDelete} +es5id: 10.1.6_A1_T2 +description: Checking funtion which returns property "arguments" +---*/ + +var ARG_STRING = "value of the argument property"; + +function f1() { + this.constructor.prototype.arguments = ARG_STRING; + return arguments; +} + +//CHECK#1 +if ((new f1(1,2,3,4,5)).length !== 5) + throw new Test262Error('#1: (new f1(1,2,3,4,5)).length===5, where f1 returns "arguments" that is set to "'+ ARG_STRING + '"'); + +//CHECK#2 +if ((new f1(1,2,3,4,5))[3] !== 4) + throw new Test262Error('#2: (new f1(1,2,3,4,5))[3]===4, where f1 returns "arguments" that is set to "'+ ARG_STRING + '"'); + +//CHECK#3 +var x = new f1(1,2,3,4,5); +if (delete x[3] !== true) + throw new Test262Error('#3.1: Function parameters have attribute {DontDelete}'); + +if (x[3] === 4) + throw new Test262Error('#3.2: Function parameters have attribute {DontDelete}'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/S10.6_A1.js b/js/src/tests/test262/language/arguments-object/S10.6_A1.js new file mode 100644 index 0000000000..0ab1510810 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/S10.6_A1.js @@ -0,0 +1,36 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + When control enters an execution context for function code, + an arguments object is created and initialised +es5id: 10.6_A1 +description: Executing function which uses arguments object +---*/ + +//CHECK#1 +function f1(){ + return arguments; +} + +try{ + var x = f1(); +} +catch(e){ + throw new Test262Error("#1: arguments doesn't exists"); +} + +//CHECK#2 +var f2 = function(){ + return arguments; +} + +try{ + var x = f2(); +} +catch(e){ + throw new Test262Error("#2: arguments doesn't exists"); +} + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/S10.6_A2.js b/js/src/tests/test262/language/arguments-object/S10.6_A2.js new file mode 100644 index 0000000000..1e1d556032 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/S10.6_A2.js @@ -0,0 +1,37 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + The value of the internal [[Prototype]] property of the + created arguments object is the original Object prototype object, the one + that is the initial value of Object.prototype +es5id: 10.6_A2 +description: Checking arguments.constructor.prototype===Object.prototype +---*/ + +//CHECK#1 +function f1(){ + return arguments.constructor.prototype; +} +try{ + if(f1() !== Object.prototype){ + throw new Test262Error('#1: arguments.constructor.prototype === Object.prototype'); + } +} +catch(e){ + throw new Test262Error("#1: arguments doesn't exists"); +} + +//CHECK#2 +var f2 = function(){return arguments.constructor.prototype;}; +try{ + if(f2() !== Object.prototype){ + throw new Test262Error('#2: arguments.constructor.prototype === Object.prototype'); + } +} +catch(e){ + throw new Test262Error("#2: arguments doesn't exists"); +} + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/S10.6_A3_T1.js b/js/src/tests/test262/language/arguments-object/S10.6_A3_T1.js new file mode 100644 index 0000000000..a8de822572 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/S10.6_A3_T1.js @@ -0,0 +1,36 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + A property is created with name callee with property + attributes { DontEnum } and no others +es5id: 10.6_A3_T1 +description: Checking existence of arguments.callee property +---*/ + +//CHECK#1 +function f1(){ + return arguments.hasOwnProperty("callee"); +} +try{ + if(f1() !== true){ + throw new Test262Error("#1: arguments object doesn't contains property 'callee'"); + } +} +catch(e){ + throw new Test262Error("#1: arguments object doesn't exists"); +} + +//CHECK#2 +var f2 = function(){return arguments.hasOwnProperty("callee");}; +try{ + if(f2() !== true){ + throw new Test262Error("#2: arguments object doesn't contains property 'callee'"); + } +} +catch(e){ + throw new Test262Error("#2: arguments object doesn't exists"); +} + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/S10.6_A3_T2.js b/js/src/tests/test262/language/arguments-object/S10.6_A3_T2.js new file mode 100644 index 0000000000..04aa017116 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/S10.6_A3_T2.js @@ -0,0 +1,50 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + A property is created with name callee with property + attributes { DontEnum } and no others +es5id: 10.6_A3_T2 +description: Checking if enumerating the arguments.callee property fails +---*/ + +//CHECK#1 +function f1(){ + for(var x in arguments){ + if (x === "callee"){ + return false; + } + } + return true; +} + +try{ + if(!f1()){ + throw new Test262Error("#1: A property callee don't have attribute { DontEnum }"); + } +} +catch(e){ + throw new Test262Error("#1: arguments object don't exists"); +} + +//CHECK#2 +var f2 = function(){ + for(var x in arguments){ + if (x === "callee"){ + return false; + } + } + return true; +} + +try{ + if(!f2()){ + throw new Test262Error("#2: A property callee don't have attribute { DontEnum }"); + } +} +catch(e){ + throw new Test262Error("#2: arguments object don't exists"); +} + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/S10.6_A3_T3.js b/js/src/tests/test262/language/arguments-object/S10.6_A3_T3.js new file mode 100644 index 0000000000..60fe503a59 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/S10.6_A3_T3.js @@ -0,0 +1,41 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + A property is created with name callee with property + attributes { DontEnum } and no others +es5id: 10.6_A3_T3 +description: Checking if deleting arguments.callee property fails +flags: [noStrict] +---*/ + +//CHECK#1 +function f1(){ + return (delete arguments.callee); +} + +try{ + if(!f1()){ + throw new Test262Error("#1: A property callee have attribute { DontDelete }"); + } +} +catch(e){ + throw new Test262Error("#1: arguments object don't exists"); +} + +//CHECK#2 +var f2 = function(){ + return (delete arguments.callee); +} + +try{ + if(!f2()){ + throw new Test262Error("#2: A property callee have attribute { DontDelete }"); + } +} +catch(e){ + throw new Test262Error("#2: arguments object don't exists"); +} + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/S10.6_A3_T4.js b/js/src/tests/test262/language/arguments-object/S10.6_A3_T4.js new file mode 100644 index 0000000000..94f11c97f2 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/S10.6_A3_T4.js @@ -0,0 +1,43 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + A property is created with name callee with property + attributes { DontEnum } and no others +es5id: 10.6_A3_T4 +description: Overriding arguments.callee property +flags: [noStrict] +---*/ + +var str = "something different"; +//CHECK#1 +function f1(){ + arguments.callee = str; + return arguments; +} + +try{ + if(f1().callee !== str){ + throw new Test262Error("#1: A property callee have attribute { ReadOnly }"); + } +} +catch(e){ + throw new Test262Error("#1: arguments object don't exists"); +} + +//CHECK#2 +var f2 = function(){ + arguments.callee = str; + return arguments; + } +try{ + if(f2().callee !== str){ + throw new Test262Error("#2: A property callee have attribute { ReadOnly }"); + } +} +catch(e){ + throw new Test262Error("#2: arguments object don't exists"); +} + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/S10.6_A4.js b/js/src/tests/test262/language/arguments-object/S10.6_A4.js new file mode 100644 index 0000000000..53571ea055 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/S10.6_A4.js @@ -0,0 +1,39 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + The initial value of the created property callee is the + Function object being executed +es5id: 10.6_A4 +description: Checking that arguments.callee === function object +flags: [noStrict] +---*/ + +//CHECK#1 +function f1(){ + return arguments.callee; +} + +try{ + if(f1 !== f1()){ + throw new Test262Error('#1: arguments.callee === f1'); + } +} +catch(e){ + throw new Test262Error("#1: arguments object doesn't exists"); +} + +//CHECK#2 +var f2 = function(){return arguments.callee;}; + +try{ + if(f2 !== f2()){ + throw new Test262Error('#2: arguments.callee === f2'); + } +} +catch(e){ + throw new Test262Error("#1: arguments object doesn't exists"); +} + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/S10.6_A5_T1.js b/js/src/tests/test262/language/arguments-object/S10.6_A5_T1.js new file mode 100644 index 0000000000..c30519e05e --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/S10.6_A5_T1.js @@ -0,0 +1,36 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + A property is created with name length with property + attributes { DontEnum } and no others +es5id: 10.6_A5_T1 +description: Checking existence of arguments.length property +---*/ + +//CHECK#1 +function f1(){ + return arguments.hasOwnProperty("length"); +} +try{ + if(f1() !== true){ + throw new Test262Error("#1: arguments object doesn't contains property 'length'"); + } +} +catch(e){ + throw new Test262Error("#1: arguments object doesn't exists"); +} + +//CHECK#2 +var f2 = function(){return arguments.hasOwnProperty("length");}; +try{ + if(f2() !== true){ + throw new Test262Error("#2: arguments object doesn't contains property 'length'"); + } +} +catch(e){ + throw new Test262Error("#2: arguments object doesn't exists"); +} + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/S10.6_A5_T2.js b/js/src/tests/test262/language/arguments-object/S10.6_A5_T2.js new file mode 100644 index 0000000000..e6cb62bb46 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/S10.6_A5_T2.js @@ -0,0 +1,50 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + A property is created with name length with property + attributes { DontEnum } and no others +es5id: 10.6_A5_T2 +description: Checking if enumerating the arguments.length property fails +---*/ + +//CHECK#1 +function f1(){ + for(var x in arguments){ + if (x === "length"){ + return false; + } + } + return true; +} + +try{ + if(!f1()){ + throw new Test262Error("#1: A property length don't have attribute { DontEnum }"); + } +} +catch(e){ + throw new Test262Error("#1: arguments object don't exists"); +} + +//CHECK#2 +var f2 = function(){ + for(var x in arguments){ + if (x === "length"){ + return false; + } + } + return true; +} + +try{ + if(!f2()){ + throw new Test262Error("#2: A property length don't have attribute { DontEnum }"); + } +} +catch(e){ + throw new Test262Error("#2: arguments object don't exists"); +} + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/S10.6_A5_T3.js b/js/src/tests/test262/language/arguments-object/S10.6_A5_T3.js new file mode 100644 index 0000000000..e3bc814660 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/S10.6_A5_T3.js @@ -0,0 +1,40 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + A property is created with name length with property + attributes { DontEnum } and no others +es5id: 10.6_A5_T3 +description: Checking if deleting arguments.length property fails +---*/ + +//CHECK#1 +function f1(){ + return (delete arguments.length); +} + +try{ + if(!f1()){ + throw new Test262Error("#1: A property length have attribute { DontDelete }"); + } +} +catch(e){ + throw new Test262Error("#1: arguments object don't exists"); +} + +//CHECK#2 +var f2 = function(){ + return (delete arguments.length); +} + +try{ + if(!f2()){ + throw new Test262Error("#2: A property length have attribute { DontDelete }"); + } +} +catch(e){ + throw new Test262Error("#2: arguments object don't exists"); +} + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/S10.6_A5_T4.js b/js/src/tests/test262/language/arguments-object/S10.6_A5_T4.js new file mode 100644 index 0000000000..d3583df422 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/S10.6_A5_T4.js @@ -0,0 +1,42 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + A property is created with name length with property + attributes { DontEnum } and no others +es5id: 10.6_A5_T4 +description: Overriding arguments.length property +---*/ + +var str = "something different"; +//CHECK#1 +function f1(){ + arguments.length = str; + return arguments; +} + +try{ + if(f1().length !== str){ + throw new Test262Error("#1: A property length have attribute { ReadOnly }"); + } +} +catch(e){ + throw new Test262Error("#1: arguments object don't exists"); +} + +//CHECK#2 +var f2 = function(){ + arguments.length = str; + return arguments; + }; +try{ + if(f2().length !== str){ + throw new Test262Error("#2: A property length have attribute { ReadOnly }"); + } +} +catch(e){ + throw new Test262Error("#2: arguments object don't exists"); +} + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/S10.6_A6.js b/js/src/tests/test262/language/arguments-object/S10.6_A6.js new file mode 100644 index 0000000000..8e9ffe3cdb --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/S10.6_A6.js @@ -0,0 +1,68 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: | + The initial value of the created property length is the number + of actual parameter values supplied by the caller +es5id: 10.6_A6 +description: Create function, that returned arguments.length +---*/ + +function f1(){ + return arguments.length; +} + +//CHECK#1 +if(!(f1() === 0)){ + throw new Test262Error('#1: argument.length === 0'); +} + +//CHECK#2 +if(!(f1(0) === 1)){ + throw new Test262Error('#2: argument.length === 1'); +} + +//CHECK#3 +if(!(f1(0, 1) === 2)){ + throw new Test262Error('#3: argument.length === 2'); +} + +//CHECK#4 +if(!(f1(0, 1, 2) === 3)){ + throw new Test262Error('#4: argument.length === 3'); +} + +//CHECK#5 +if(!(f1(0, 1, 2, 3) === 4)){ + throw new Test262Error('#5: argument.length === 4'); +} + +var f2 = function(){return arguments.length;}; + +//CHECK#6 +if(!(f2() === 0)){ + throw new Test262Error('#6: argument.length === 0'); +} + +//CHECK#7 +if(!(f2(0) === 1)){ + throw new Test262Error('#7: argument.length === 1'); +} + +//CHECK#8 +if(!(f2(0, 1) === 2)){ + throw new Test262Error('#8: argument.length === 2'); +} + +//CHECK#9 +if(!(f2(0, 1, 2) === 3)){ + throw new Test262Error('#9: argument.length === 3'); +} + +//CHECK#10 +if(!(f2(0, 1, 2, 3) === 4)){ + throw new Test262Error('#10: argument.length === 4'); +} + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/S10.6_A7.js b/js/src/tests/test262/language/arguments-object/S10.6_A7.js new file mode 100644 index 0000000000..0a22e7112c --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/S10.6_A7.js @@ -0,0 +1,20 @@ +// Copyright 2009 the Sputnik authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Get arguments of function +es5id: 10.6_A7 +description: Use property arguments +---*/ + +function f1() { + return arguments; +} + +//CHECK#1-5 +for(var i = 1; i < 5; i++){ + if (f1(1,2,3,4,5)[i] !== (i+1)) + throw new Test262Error("#"+i+": Returning function's arguments work wrong, f1(1,2,3,4,5)["+i+"] !== "+(i+1)); +} + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/arguments-caller.js b/js/src/tests/test262/language/arguments-object/arguments-caller.js new file mode 100644 index 0000000000..5276952550 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/arguments-caller.js @@ -0,0 +1,14 @@ +// Copyright (c) 2016 Kevin Gibbons. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-arguments-exotic-objects +description: arguments.caller does not exist +---*/ + +function getArguments() { + return arguments; +} +assert.sameValue(Object.getOwnPropertyDescriptor(getArguments(), 'caller'), undefined, 'arguments.caller does not exist'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/async-gen-meth-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/async-gen-meth-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..84b745a698 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/async-gen-meth-args-trailing-comma-multiple.js @@ -0,0 +1,56 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/async-gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (async generator method) +esid: sec-asyncgenerator-definitions-propertydefinitionevaluation +features: [async-iteration] +flags: [generated, async] +info: | + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + +var callCount = 0; +var obj = { + async *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; + } +}; + +// Stores a reference `ref` for case evaluation +var ref = obj.method; + +ref(42, 'TC39',).next().then(() => { + assert.sameValue(callCount, 1, 'generator method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/async-gen-meth-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/async-gen-meth-args-trailing-comma-null.js new file mode 100644 index 0000000000..7c59db0f4b --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/async-gen-meth-args-trailing-comma-null.js @@ -0,0 +1,56 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/async-gen-meth.template +/*--- +description: A trailing comma after null should not increase the arguments.length (async generator method) +esid: sec-asyncgenerator-definitions-propertydefinitionevaluation +features: [async-iteration] +flags: [generated, async] +info: | + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + +var callCount = 0; +var obj = { + async *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; + } +}; + +// Stores a reference `ref` for case evaluation +var ref = obj.method; + +ref(42, null,).next().then(() => { + assert.sameValue(callCount, 1, 'generator method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/async-gen-meth-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/async-gen-meth-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..6f43609fc0 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/async-gen-meth-args-trailing-comma-single-args.js @@ -0,0 +1,55 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/async-gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (async generator method) +esid: sec-asyncgenerator-definitions-propertydefinitionevaluation +features: [async-iteration] +flags: [generated, async] +info: | + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + +var callCount = 0; +var obj = { + async *method() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; + } +}; + +// Stores a reference `ref` for case evaluation +var ref = obj.method; + +ref(42,).next().then(() => { + assert.sameValue(callCount, 1, 'generator method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/async-gen-meth-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/async-gen-meth-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..607eef915b --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/async-gen-meth-args-trailing-comma-spread-operator.js @@ -0,0 +1,60 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/async-gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (async generator method) +esid: sec-asyncgenerator-definitions-propertydefinitionevaluation +features: [async-iteration] +flags: [generated, async] +info: | + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + +var callCount = 0; +var obj = { + async *method() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; + } +}; + +// Stores a reference `ref` for case evaluation +var ref = obj.method; + +ref(42, ...[1], ...arr,).next().then(() => { + assert.sameValue(callCount, 1, 'generator method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/async-gen-meth-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/async-gen-meth-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..b0cabe0ac6 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/async-gen-meth-args-trailing-comma-undefined.js @@ -0,0 +1,56 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/async-gen-meth.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (async generator method) +esid: sec-asyncgenerator-definitions-propertydefinitionevaluation +features: [async-iteration] +flags: [generated, async] +info: | + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + +var callCount = 0; +var obj = { + async *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; + } +}; + +// Stores a reference `ref` for case evaluation +var ref = obj.method; + +ref(42, undefined,).next().then(() => { + assert.sameValue(callCount, 1, 'generator method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/async-gen-named-func-expr-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/async-gen-named-func-expr-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..905b3ae824 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/async-gen-named-func-expr-args-trailing-comma-multiple.js @@ -0,0 +1,49 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/async-gen-named-func-expr.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (async generator named function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated, async] +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, funcEnv, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +var ref; +ref = async function* g() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; +}; + +ref(42, 'TC39',).next().then(() => { + assert.sameValue(callCount, 1, 'generator function invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/async-gen-named-func-expr-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/async-gen-named-func-expr-args-trailing-comma-null.js new file mode 100644 index 0000000000..5ebac2ff7e --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/async-gen-named-func-expr-args-trailing-comma-null.js @@ -0,0 +1,49 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/async-gen-named-func-expr.template +/*--- +description: A trailing comma after null should not increase the arguments.length (async generator named function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated, async] +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, funcEnv, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +var ref; +ref = async function* g() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; +}; + +ref(42, null,).next().then(() => { + assert.sameValue(callCount, 1, 'generator function invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/async-gen-named-func-expr-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/async-gen-named-func-expr-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..641a08a94c --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/async-gen-named-func-expr-args-trailing-comma-single-args.js @@ -0,0 +1,48 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/async-gen-named-func-expr.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (async generator named function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated, async] +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, funcEnv, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +var ref; +ref = async function* g() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; +}; + +ref(42,).next().then(() => { + assert.sameValue(callCount, 1, 'generator function invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/async-gen-named-func-expr-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/async-gen-named-func-expr-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..5f16f6e707 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/async-gen-named-func-expr-args-trailing-comma-spread-operator.js @@ -0,0 +1,53 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/async-gen-named-func-expr.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (async generator named function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated, async] +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, funcEnv, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +var ref; +ref = async function* g() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; +}; + +ref(42, ...[1], ...arr,).next().then(() => { + assert.sameValue(callCount, 1, 'generator function invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/async-gen-named-func-expr-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/async-gen-named-func-expr-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..0eaa11cb5a --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/async-gen-named-func-expr-args-trailing-comma-undefined.js @@ -0,0 +1,49 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/async-gen-named-func-expr.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (async generator named function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated, async] +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 7. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, funcEnv, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +var ref; +ref = async function* g() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; +}; + +ref(42, undefined,).next().then(() => { + assert.sameValue(callCount, 1, 'generator function invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/browser.js b/js/src/tests/test262/language/arguments-object/browser.js new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/browser.js diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-func-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-func-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..5229f519f4 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-func-args-trailing-comma-multiple.js @@ -0,0 +1,48 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/async-gen-func-decl.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (async generator function declaration) +esid: sec-asyncgenerator-definitions-instantiatefunctionobject +features: [async-iteration] +flags: [generated, async] +info: | + AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody, + scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +async function* ref() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; +} + +ref(42, 'TC39',).next().then(() => { + assert.sameValue(callCount, 1, 'generator function invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-func-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-func-args-trailing-comma-null.js new file mode 100644 index 0000000000..b81596454a --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-func-args-trailing-comma-null.js @@ -0,0 +1,48 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/async-gen-func-decl.template +/*--- +description: A trailing comma after null should not increase the arguments.length (async generator function declaration) +esid: sec-asyncgenerator-definitions-instantiatefunctionobject +features: [async-iteration] +flags: [generated, async] +info: | + AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody, + scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +async function* ref() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; +} + +ref(42, null,).next().then(() => { + assert.sameValue(callCount, 1, 'generator function invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-func-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-func-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..560af6e844 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-func-args-trailing-comma-single-args.js @@ -0,0 +1,47 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/async-gen-func-decl.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (async generator function declaration) +esid: sec-asyncgenerator-definitions-instantiatefunctionobject +features: [async-iteration] +flags: [generated, async] +info: | + AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody, + scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +async function* ref() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; +} + +ref(42,).next().then(() => { + assert.sameValue(callCount, 1, 'generator function invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-func-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-func-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..ad895f5d22 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-func-args-trailing-comma-spread-operator.js @@ -0,0 +1,52 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/async-gen-func-decl.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (async generator function declaration) +esid: sec-asyncgenerator-definitions-instantiatefunctionobject +features: [async-iteration] +flags: [generated, async] +info: | + AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody, + scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +async function* ref() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; +} + +ref(42, ...[1], ...arr,).next().then(() => { + assert.sameValue(callCount, 1, 'generator function invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-func-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-func-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..a2b5b4cc25 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-func-args-trailing-comma-undefined.js @@ -0,0 +1,48 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/async-gen-func-decl.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (async generator function declaration) +esid: sec-asyncgenerator-definitions-instantiatefunctionobject +features: [async-iteration] +flags: [generated, async] +info: | + AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier + ( FormalParameters ) { AsyncGeneratorBody } + + [...] + 3. Let F be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, AsyncGeneratorBody, + scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +async function* ref() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; +} + +ref(42, undefined,).next().then(() => { + assert.sameValue(callCount, 1, 'generator function invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..c38d172b25 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-args-trailing-comma-multiple.js @@ -0,0 +1,74 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/cls-decl-async-gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated, async] +info: | + ClassDeclaration : class BindingIdentifier ClassTail + + 1. Let className be StringValue of BindingIdentifier. + 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with + argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + +var callCount = 0; +class C { + async *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; + } +} + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +ref(42, 'TC39',).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-args-trailing-comma-null.js new file mode 100644 index 0000000000..031939ce32 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-args-trailing-comma-null.js @@ -0,0 +1,74 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/cls-decl-async-gen-meth.template +/*--- +description: A trailing comma after null should not increase the arguments.length (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated, async] +info: | + ClassDeclaration : class BindingIdentifier ClassTail + + 1. Let className be StringValue of BindingIdentifier. + 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with + argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + +var callCount = 0; +class C { + async *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; + } +} + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +ref(42, null,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..8fac0d78c5 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-args-trailing-comma-single-args.js @@ -0,0 +1,73 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/cls-decl-async-gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated, async] +info: | + ClassDeclaration : class BindingIdentifier ClassTail + + 1. Let className be StringValue of BindingIdentifier. + 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with + argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + +var callCount = 0; +class C { + async *method() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; + } +} + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +ref(42,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..6ece8ba21d --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-args-trailing-comma-spread-operator.js @@ -0,0 +1,78 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/cls-decl-async-gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated, async] +info: | + ClassDeclaration : class BindingIdentifier ClassTail + + 1. Let className be StringValue of BindingIdentifier. + 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with + argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + +var callCount = 0; +class C { + async *method() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; + } +} + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +ref(42, ...[1], ...arr,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..1119a6812d --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-args-trailing-comma-undefined.js @@ -0,0 +1,74 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/cls-decl-async-gen-meth.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (class expression method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated, async] +info: | + ClassDeclaration : class BindingIdentifier ClassTail + + 1. Let className be StringValue of BindingIdentifier. + 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with + argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + +var callCount = 0; +class C { + async *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; + } +} + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +ref(42, undefined,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-static-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-static-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..32053bcf61 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-static-args-trailing-comma-multiple.js @@ -0,0 +1,75 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/cls-decl-async-gen-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (static class expression generator method) +esid: sec-runtime-semantics-bindingclassdeclarationevaluation +features: [async-iteration] +flags: [generated, async] +info: | + ClassDeclaration : class BindingIdentifier ClassTail + + 1. Let className be StringValue of BindingIdentifier. + 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with + argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + static async *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; + } +} + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +ref(42, 'TC39',).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-static-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-static-args-trailing-comma-null.js new file mode 100644 index 0000000000..6215495a3c --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-static-args-trailing-comma-null.js @@ -0,0 +1,75 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/cls-decl-async-gen-meth-static.template +/*--- +description: A trailing comma after null should not increase the arguments.length (static class expression generator method) +esid: sec-runtime-semantics-bindingclassdeclarationevaluation +features: [async-iteration] +flags: [generated, async] +info: | + ClassDeclaration : class BindingIdentifier ClassTail + + 1. Let className be StringValue of BindingIdentifier. + 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with + argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + static async *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; + } +} + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +ref(42, null,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-static-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-static-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..af9d5ef2c5 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-static-args-trailing-comma-single-args.js @@ -0,0 +1,74 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/cls-decl-async-gen-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (static class expression generator method) +esid: sec-runtime-semantics-bindingclassdeclarationevaluation +features: [async-iteration] +flags: [generated, async] +info: | + ClassDeclaration : class BindingIdentifier ClassTail + + 1. Let className be StringValue of BindingIdentifier. + 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with + argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + static async *method() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; + } +} + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +ref(42,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-static-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-static-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..cf63b04f37 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-static-args-trailing-comma-spread-operator.js @@ -0,0 +1,79 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/cls-decl-async-gen-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (static class expression generator method) +esid: sec-runtime-semantics-bindingclassdeclarationevaluation +features: [async-iteration] +flags: [generated, async] +info: | + ClassDeclaration : class BindingIdentifier ClassTail + + 1. Let className be StringValue of BindingIdentifier. + 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with + argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +class C { + static async *method() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; + } +} + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +ref(42, ...[1], ...arr,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-static-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-static-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..d0b44c992e --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-async-gen-meth-static-args-trailing-comma-undefined.js @@ -0,0 +1,75 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/cls-decl-async-gen-meth-static.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (static class expression generator method) +esid: sec-runtime-semantics-bindingclassdeclarationevaluation +features: [async-iteration] +flags: [generated, async] +info: | + ClassDeclaration : class BindingIdentifier ClassTail + + 1. Let className be StringValue of BindingIdentifier. + 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with + argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation for + m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + static async *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; + } +} + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +ref(42, undefined,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..b3350dd996 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-args-trailing-comma-multiple.js @@ -0,0 +1,75 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/cls-decl-async-private-gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (static class declaration private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [async-iteration, class, class-methods-private] +flags: [generated, async] +info: | + ClassDeclaration : class BindingIdentifier ClassTail + + 1. Let className be StringValue of BindingIdentifier. + 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with + argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + +var callCount = 0; +class C { + async * #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +} + +new C().method(42, 'TC39',).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-args-trailing-comma-null.js new file mode 100644 index 0000000000..b55faa8fc0 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-args-trailing-comma-null.js @@ -0,0 +1,75 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/cls-decl-async-private-gen-meth.template +/*--- +description: A trailing comma after null should not increase the arguments.length (static class declaration private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [async-iteration, class, class-methods-private] +flags: [generated, async] +info: | + ClassDeclaration : class BindingIdentifier ClassTail + + 1. Let className be StringValue of BindingIdentifier. + 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with + argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + +var callCount = 0; +class C { + async * #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +} + +new C().method(42, null,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..c267618428 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-args-trailing-comma-single-args.js @@ -0,0 +1,74 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/cls-decl-async-private-gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (static class declaration private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [async-iteration, class, class-methods-private] +flags: [generated, async] +info: | + ClassDeclaration : class BindingIdentifier ClassTail + + 1. Let className be StringValue of BindingIdentifier. + 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with + argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + +var callCount = 0; +class C { + async * #method() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +} + +new C().method(42,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..18f20b6678 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-args-trailing-comma-spread-operator.js @@ -0,0 +1,79 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/cls-decl-async-private-gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (static class declaration private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [async-iteration, class, class-methods-private] +flags: [generated, async] +info: | + ClassDeclaration : class BindingIdentifier ClassTail + + 1. Let className be StringValue of BindingIdentifier. + 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with + argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + +var callCount = 0; +class C { + async * #method() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +} + +new C().method(42, ...[1], ...arr,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..e7bf8e0c42 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-args-trailing-comma-undefined.js @@ -0,0 +1,75 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/cls-decl-async-private-gen-meth.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (static class declaration private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [async-iteration, class, class-methods-private] +flags: [generated, async] +info: | + ClassDeclaration : class BindingIdentifier ClassTail + + 1. Let className be StringValue of BindingIdentifier. + 2. Let value be the result of ClassDefinitionEvaluation of ClassTail with + argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + +var callCount = 0; +class C { + async * #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +} + +new C().method(42, undefined,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-static-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-static-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..7c17a6a375 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-static-args-trailing-comma-multiple.js @@ -0,0 +1,56 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/cls-decl-async-private-gen-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (static class expression private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [async-iteration, class, class-static-methods-private] +flags: [generated, async] +info: | + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + static async * #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +} + +C.method(42, 'TC39',).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-static-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-static-args-trailing-comma-null.js new file mode 100644 index 0000000000..4dc426ad1d --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-static-args-trailing-comma-null.js @@ -0,0 +1,56 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/cls-decl-async-private-gen-meth-static.template +/*--- +description: A trailing comma after null should not increase the arguments.length (static class expression private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [async-iteration, class, class-static-methods-private] +flags: [generated, async] +info: | + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + static async * #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +} + +C.method(42, null,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-static-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-static-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..44b9b24fe4 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-static-args-trailing-comma-single-args.js @@ -0,0 +1,55 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/cls-decl-async-private-gen-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (static class expression private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [async-iteration, class, class-static-methods-private] +flags: [generated, async] +info: | + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + static async * #method() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +} + +C.method(42,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-static-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-static-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..404a0c93f8 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-static-args-trailing-comma-spread-operator.js @@ -0,0 +1,60 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/cls-decl-async-private-gen-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (static class expression private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [async-iteration, class, class-static-methods-private] +flags: [generated, async] +info: | + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +class C { + static async * #method() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +} + +C.method(42, ...[1], ...arr,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-static-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-static-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..c3bac83420 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-async-private-gen-meth-static-args-trailing-comma-undefined.js @@ -0,0 +1,56 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/cls-decl-async-private-gen-meth-static.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (static class expression private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [async-iteration, class, class-static-methods-private] +flags: [generated, async] +info: | + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + static async * #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +} + +C.method(42, undefined,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..7ef0401a22 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-args-trailing-comma-multiple.js @@ -0,0 +1,51 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/cls-decl-gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (class declaration generator method) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; + } +} + +C.prototype.method(42, 'TC39',).next(); + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-args-trailing-comma-null.js new file mode 100644 index 0000000000..4fff6d029d --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-args-trailing-comma-null.js @@ -0,0 +1,51 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/cls-decl-gen-meth.template +/*--- +description: A trailing comma after null should not increase the arguments.length (class declaration generator method) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; + } +} + +C.prototype.method(42, null,).next(); + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..214d652bda --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-args-trailing-comma-single-args.js @@ -0,0 +1,50 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/cls-decl-gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (class declaration generator method) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + *method() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; + } +} + +C.prototype.method(42,).next(); + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..bd32f75bbc --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-args-trailing-comma-spread-operator.js @@ -0,0 +1,55 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/cls-decl-gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (class declaration generator method) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +class C { + *method() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; + } +} + +C.prototype.method(42, ...[1], ...arr,).next(); + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..ec9fbe921d --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-args-trailing-comma-undefined.js @@ -0,0 +1,51 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/cls-decl-gen-meth.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (class declaration generator method) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; + } +} + +C.prototype.method(42, undefined,).next(); + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-static-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-static-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..84fbdab101 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-static-args-trailing-comma-multiple.js @@ -0,0 +1,51 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/cls-decl-gen-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (class declaration generator method) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + static *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; + } +} + +C.method(42, 'TC39',).next(); + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-static-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-static-args-trailing-comma-null.js new file mode 100644 index 0000000000..49d4e14594 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-static-args-trailing-comma-null.js @@ -0,0 +1,51 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/cls-decl-gen-meth-static.template +/*--- +description: A trailing comma after null should not increase the arguments.length (class declaration generator method) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + static *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; + } +} + +C.method(42, null,).next(); + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-static-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-static-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..62ec275158 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-static-args-trailing-comma-single-args.js @@ -0,0 +1,50 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/cls-decl-gen-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (class declaration generator method) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + static *method() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; + } +} + +C.method(42,).next(); + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-static-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-static-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..09d2269e0b --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-static-args-trailing-comma-spread-operator.js @@ -0,0 +1,55 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/cls-decl-gen-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (class declaration generator method) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +class C { + static *method() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; + } +} + +C.method(42, ...[1], ...arr,).next(); + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-static-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-static-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..9039ea2ad6 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-gen-meth-static-args-trailing-comma-undefined.js @@ -0,0 +1,51 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/cls-decl-gen-meth-static.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (class declaration generator method) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + static *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; + } +} + +C.method(42, undefined,).next(); + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-meth-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/cls-decl-meth-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..c5a0276747 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-meth-args-trailing-comma-multiple.js @@ -0,0 +1,49 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/cls-decl-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (class declaration method) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; + } +} + +C.prototype.method(42, 'TC39',); + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-meth-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/cls-decl-meth-args-trailing-comma-null.js new file mode 100644 index 0000000000..f5042adb09 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-meth-args-trailing-comma-null.js @@ -0,0 +1,49 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/cls-decl-meth.template +/*--- +description: A trailing comma after null should not increase the arguments.length (class declaration method) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; + } +} + +C.prototype.method(42, null,); + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-meth-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/cls-decl-meth-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..429e9358aa --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-meth-args-trailing-comma-single-args.js @@ -0,0 +1,48 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/cls-decl-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (class declaration method) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + method() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; + } +} + +C.prototype.method(42,); + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-meth-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/cls-decl-meth-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..0cfa422b0b --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-meth-args-trailing-comma-spread-operator.js @@ -0,0 +1,53 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/cls-decl-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (class declaration method) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +class C { + method() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; + } +} + +C.prototype.method(42, ...[1], ...arr,); + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-meth-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/cls-decl-meth-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..abb7380be4 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-meth-args-trailing-comma-undefined.js @@ -0,0 +1,49 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/cls-decl-meth.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (class declaration method) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; + } +} + +C.prototype.method(42, undefined,); + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-meth-static-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/cls-decl-meth-static-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..5dca46e339 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-meth-static-args-trailing-comma-multiple.js @@ -0,0 +1,49 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/cls-decl-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (static class declaration method) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + static method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; + } +} + +C.method(42, 'TC39',); + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-meth-static-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/cls-decl-meth-static-args-trailing-comma-null.js new file mode 100644 index 0000000000..d3beb7c09c --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-meth-static-args-trailing-comma-null.js @@ -0,0 +1,49 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/cls-decl-meth-static.template +/*--- +description: A trailing comma after null should not increase the arguments.length (static class declaration method) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + static method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; + } +} + +C.method(42, null,); + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-meth-static-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/cls-decl-meth-static-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..113fd6f98b --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-meth-static-args-trailing-comma-single-args.js @@ -0,0 +1,48 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/cls-decl-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (static class declaration method) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + static method() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; + } +} + +C.method(42,); + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-meth-static-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/cls-decl-meth-static-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..b0cb1b1c6b --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-meth-static-args-trailing-comma-spread-operator.js @@ -0,0 +1,53 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/cls-decl-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (static class declaration method) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +class C { + static method() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; + } +} + +C.method(42, ...[1], ...arr,); + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-meth-static-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/cls-decl-meth-static-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..100cd25594 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-meth-static-args-trailing-comma-undefined.js @@ -0,0 +1,49 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/cls-decl-meth-static.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (static class declaration method) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + static method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; + } +} + +C.method(42, undefined,); + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..adad33d366 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-args-trailing-comma-multiple.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/cls-decl-private-gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (class declaration private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [generators, class, class-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + * #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +} + +new C().method(42, 'TC39',).next(); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-args-trailing-comma-null.js new file mode 100644 index 0000000000..926a6877c1 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-args-trailing-comma-null.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/cls-decl-private-gen-meth.template +/*--- +description: A trailing comma after null should not increase the arguments.length (class declaration private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [generators, class, class-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + * #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +} + +new C().method(42, null,).next(); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..f14bdf279e --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-args-trailing-comma-single-args.js @@ -0,0 +1,51 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/cls-decl-private-gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (class declaration private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [generators, class, class-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + * #method() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +} + +new C().method(42,).next(); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..88e9e652a2 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-args-trailing-comma-spread-operator.js @@ -0,0 +1,56 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/cls-decl-private-gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (class declaration private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [generators, class, class-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +class C { + * #method() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +} + +new C().method(42, ...[1], ...arr,).next(); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..bde3b71ec1 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-args-trailing-comma-undefined.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/cls-decl-private-gen-meth.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (class declaration private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [generators, class, class-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + * #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +} + +new C().method(42, undefined,).next(); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-static-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-static-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..6c05f361b7 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-static-args-trailing-comma-multiple.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/cls-decl-private-gen-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (class declaration private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [generators, class, class-static-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + static * #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +} + +C.method(42, 'TC39',).next(); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-static-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-static-args-trailing-comma-null.js new file mode 100644 index 0000000000..87149d6768 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-static-args-trailing-comma-null.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/cls-decl-private-gen-meth-static.template +/*--- +description: A trailing comma after null should not increase the arguments.length (class declaration private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [generators, class, class-static-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + static * #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +} + +C.method(42, null,).next(); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-static-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-static-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..3e203c2969 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-static-args-trailing-comma-single-args.js @@ -0,0 +1,51 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/cls-decl-private-gen-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (class declaration private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [generators, class, class-static-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + static * #method() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +} + +C.method(42,).next(); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-static-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-static-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..cc06b87808 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-static-args-trailing-comma-spread-operator.js @@ -0,0 +1,56 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/cls-decl-private-gen-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (class declaration private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [generators, class, class-static-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +class C { + static * #method() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +} + +C.method(42, ...[1], ...arr,).next(); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-static-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-static-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..075b303965 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-private-gen-meth-static-args-trailing-comma-undefined.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/cls-decl-private-gen-meth-static.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (class declaration private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [generators, class, class-static-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + static * #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +} + +C.method(42, undefined,).next(); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..8ebe343f23 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-args-trailing-comma-multiple.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/cls-decl-private-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (class declaration private method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [class, class-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +} + +new C().method(42, 'TC39',); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-args-trailing-comma-null.js new file mode 100644 index 0000000000..e11834be6f --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-args-trailing-comma-null.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/cls-decl-private-meth.template +/*--- +description: A trailing comma after null should not increase the arguments.length (class declaration private method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [class, class-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +} + +new C().method(42, null,); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..3190e3ce15 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-args-trailing-comma-single-args.js @@ -0,0 +1,51 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/cls-decl-private-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (class declaration private method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [class, class-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + #method() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +} + +new C().method(42,); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..8aae75ff6e --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-args-trailing-comma-spread-operator.js @@ -0,0 +1,56 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/cls-decl-private-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (class declaration private method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [class, class-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +class C { + #method() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +} + +new C().method(42, ...[1], ...arr,); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..845dbd4b38 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-args-trailing-comma-undefined.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/cls-decl-private-meth.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (class declaration private method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [class, class-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +} + +new C().method(42, undefined,); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-static-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-static-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..da69fa67bb --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-static-args-trailing-comma-multiple.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/cls-decl-private-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (static class declaration private method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [class, class-static-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + static #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +} + +C.method(42, 'TC39',); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-static-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-static-args-trailing-comma-null.js new file mode 100644 index 0000000000..80ec052852 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-static-args-trailing-comma-null.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/cls-decl-private-meth-static.template +/*--- +description: A trailing comma after null should not increase the arguments.length (static class declaration private method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [class, class-static-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + static #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +} + +C.method(42, null,); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-static-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-static-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..b3332fbe2c --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-static-args-trailing-comma-single-args.js @@ -0,0 +1,51 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/cls-decl-private-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (static class declaration private method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [class, class-static-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + static #method() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +} + +C.method(42,); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-static-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-static-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..ca2cbd696e --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-static-args-trailing-comma-spread-operator.js @@ -0,0 +1,56 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/cls-decl-private-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (static class declaration private method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [class, class-static-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +class C { + static #method() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +} + +C.method(42, ...[1], ...arr,); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-static-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-static-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..624ae70fe3 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-decl-private-meth-static-args-trailing-comma-undefined.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/cls-decl-private-meth-static.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (static class declaration private method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [class, class-static-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +class C { + static #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +} + +C.method(42, undefined,); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-func-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-func-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..907f2d5de6 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-func-args-trailing-comma-multiple.js @@ -0,0 +1,49 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/async-gen-func-expr.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (async generator function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated, async] +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) { + AsyncGeneratorBody } + + [...] + 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +var ref; +ref = async function*() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; +}; + +ref(42, 'TC39',).next().then(() => { + assert.sameValue(callCount, 1, 'generator function invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-func-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-func-args-trailing-comma-null.js new file mode 100644 index 0000000000..c389f1ec4c --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-func-args-trailing-comma-null.js @@ -0,0 +1,49 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/async-gen-func-expr.template +/*--- +description: A trailing comma after null should not increase the arguments.length (async generator function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated, async] +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) { + AsyncGeneratorBody } + + [...] + 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +var ref; +ref = async function*() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; +}; + +ref(42, null,).next().then(() => { + assert.sameValue(callCount, 1, 'generator function invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-func-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-func-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..4a5d11c495 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-func-args-trailing-comma-single-args.js @@ -0,0 +1,48 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/async-gen-func-expr.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (async generator function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated, async] +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) { + AsyncGeneratorBody } + + [...] + 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +var ref; +ref = async function*() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; +}; + +ref(42,).next().then(() => { + assert.sameValue(callCount, 1, 'generator function invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-func-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-func-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..a4a64f3722 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-func-args-trailing-comma-spread-operator.js @@ -0,0 +1,53 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/async-gen-func-expr.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (async generator function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated, async] +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) { + AsyncGeneratorBody } + + [...] + 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +var ref; +ref = async function*() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; +}; + +ref(42, ...[1], ...arr,).next().then(() => { + assert.sameValue(callCount, 1, 'generator function invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-func-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-func-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..1f42ccbde8 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-func-args-trailing-comma-undefined.js @@ -0,0 +1,49 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/async-gen-func-expr.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (async generator function expression) +esid: sec-asyncgenerator-definitions-evaluation +features: [async-iteration] +flags: [generated, async] +info: | + AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) { + AsyncGeneratorBody } + + [...] + 3. Let closure be ! AsyncGeneratorFunctionCreate(Normal, FormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +var ref; +ref = async function*() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; +}; + +ref(42, undefined,).next().then(() => { + assert.sameValue(callCount, 1, 'generator function invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..596a517ba3 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-args-trailing-comma-multiple.js @@ -0,0 +1,77 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/cls-expr-async-gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated, async] +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + async *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; + } +}; + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +ref(42, 'TC39',).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); + diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-args-trailing-comma-null.js new file mode 100644 index 0000000000..4766ae650d --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-args-trailing-comma-null.js @@ -0,0 +1,77 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/cls-expr-async-gen-meth.template +/*--- +description: A trailing comma after null should not increase the arguments.length (class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated, async] +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + async *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; + } +}; + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +ref(42, null,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); + diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..a06bf5723b --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-args-trailing-comma-single-args.js @@ -0,0 +1,76 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/cls-expr-async-gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated, async] +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + async *method() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; + } +}; + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +ref(42,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); + diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..86fbb5e4f5 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-args-trailing-comma-spread-operator.js @@ -0,0 +1,81 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/cls-expr-async-gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated, async] +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +var C = class { + async *method() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; + } +}; + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +ref(42, ...[1], ...arr,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); + diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..d0002fde3b --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-args-trailing-comma-undefined.js @@ -0,0 +1,77 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/cls-expr-async-gen-meth.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated, async] +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + async *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; + } +}; + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +ref(42, undefined,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); + diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-static-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-static-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..c6b3065922 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-static-args-trailing-comma-multiple.js @@ -0,0 +1,76 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/cls-expr-async-gen-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (static class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated, async] +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + static async *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; + } +}; + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +ref(42, 'TC39',).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-static-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-static-args-trailing-comma-null.js new file mode 100644 index 0000000000..23cbbd7e2c --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-static-args-trailing-comma-null.js @@ -0,0 +1,76 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/cls-expr-async-gen-meth-static.template +/*--- +description: A trailing comma after null should not increase the arguments.length (static class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated, async] +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + static async *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; + } +}; + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +ref(42, null,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-static-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-static-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..99a763eb76 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-static-args-trailing-comma-single-args.js @@ -0,0 +1,75 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/cls-expr-async-gen-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (static class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated, async] +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + static async *method() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; + } +}; + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +ref(42,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-static-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-static-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..292829d569 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-static-args-trailing-comma-spread-operator.js @@ -0,0 +1,80 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/cls-expr-async-gen-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (static class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated, async] +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +var C = class { + static async *method() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; + } +}; + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +ref(42, ...[1], ...arr,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-static-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-static-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..2608243b16 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-async-gen-meth-static-args-trailing-comma-undefined.js @@ -0,0 +1,76 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/cls-expr-async-gen-meth-static.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (static class expression async generator method) +esid: sec-class-definitions-runtime-semantics-evaluation +features: [async-iteration] +flags: [generated, async] +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + static async *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; + } +}; + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +ref(42, undefined,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..3b8f44b995 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-args-trailing-comma-multiple.js @@ -0,0 +1,78 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/cls-expr-async-private-gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (class expression async private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [async-iteration, class, class-methods-private] +flags: [generated, async] +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + async * #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method(42, 'TC39',).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); + diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-args-trailing-comma-null.js new file mode 100644 index 0000000000..6c87a97faa --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-args-trailing-comma-null.js @@ -0,0 +1,78 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/cls-expr-async-private-gen-meth.template +/*--- +description: A trailing comma after null should not increase the arguments.length (class expression async private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [async-iteration, class, class-methods-private] +flags: [generated, async] +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + async * #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method(42, null,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); + diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..d1e0518e07 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-args-trailing-comma-single-args.js @@ -0,0 +1,77 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/cls-expr-async-private-gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (class expression async private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [async-iteration, class, class-methods-private] +flags: [generated, async] +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + async * #method() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method(42,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); + diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..1b2532dba4 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-args-trailing-comma-spread-operator.js @@ -0,0 +1,82 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/cls-expr-async-private-gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (class expression async private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [async-iteration, class, class-methods-private] +flags: [generated, async] +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +var C = class { + async * #method() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method(42, ...[1], ...arr,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); + diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..07befbe246 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-args-trailing-comma-undefined.js @@ -0,0 +1,78 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/cls-expr-async-private-gen-meth.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (class expression async private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [async-iteration, class, class-methods-private] +flags: [generated, async] +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + i. Let status be the result of performing + PropertyDefinitionEvaluation for m with arguments proto and + false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + async * #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method(42, undefined,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); + diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-static-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-static-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..8bf6c86666 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-static-args-trailing-comma-multiple.js @@ -0,0 +1,77 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/cls-expr-async-private-gen-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (static class expression async private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [async-iteration, class, class-static-methods-private] +flags: [generated, async] +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + static async * #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method(42, 'TC39',).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-static-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-static-args-trailing-comma-null.js new file mode 100644 index 0000000000..5b7b6a9d78 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-static-args-trailing-comma-null.js @@ -0,0 +1,77 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/cls-expr-async-private-gen-meth-static.template +/*--- +description: A trailing comma after null should not increase the arguments.length (static class expression async private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [async-iteration, class, class-static-methods-private] +flags: [generated, async] +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + static async * #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method(42, null,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-static-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-static-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..2e93f650e2 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-static-args-trailing-comma-single-args.js @@ -0,0 +1,76 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/cls-expr-async-private-gen-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (static class expression async private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [async-iteration, class, class-static-methods-private] +flags: [generated, async] +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + static async * #method() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method(42,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-static-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-static-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..863740aae5 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-static-args-trailing-comma-spread-operator.js @@ -0,0 +1,81 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/cls-expr-async-private-gen-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (static class expression async private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [async-iteration, class, class-static-methods-private] +flags: [generated, async] +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +var C = class { + static async * #method() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method(42, ...[1], ...arr,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-static-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-static-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..482a65094b --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-async-private-gen-meth-static-args-trailing-comma-undefined.js @@ -0,0 +1,77 @@ +// |reftest| async +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/cls-expr-async-private-gen-meth-static.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (static class expression async private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [async-iteration, class, class-static-methods-private] +flags: [generated, async] +info: | + ClassExpression : class BindingIdentifieropt ClassTail + + 1. If BindingIdentifieropt is not present, let className be undefined. + 2. Else, let className be StringValue of BindingIdentifier. + 3. Let value be the result of ClassDefinitionEvaluation of ClassTail + with argument className. + [...] + + 14.5.14 Runtime Semantics: ClassDefinitionEvaluation + + 21. For each ClassElement m in order from methods + a. If IsStatic of m is false, then + b. Else, + Let status be the result of performing PropertyDefinitionEvaluation + for m with arguments F and false. + [...] + + Runtime Semantics: PropertyDefinitionEvaluation + + AsyncGeneratorMethod : + async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) + { AsyncGeneratorBody } + + 1. Let propKey be the result of evaluating PropertyName. + 2. ReturnIfAbrupt(propKey). + 3. If the function code for this AsyncGeneratorMethod is strict mode code, let strict be true. + Otherwise let strict be false. + 4. Let scope be the running execution context's LexicalEnvironment. + 5. Let closure be ! AsyncGeneratorFunctionCreate(Method, UniqueFormalParameters, + AsyncGeneratorBody, scope, strict). + [...] + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + static async * #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method(42, undefined,).next().then(() => { + assert.sameValue(callCount, 1, 'method invoked exactly once'); +}).then($DONE, $DONE); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..00f5d8ba64 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-args-trailing-comma-multiple.js @@ -0,0 +1,51 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/cls-expr-gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (class expression generator method) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; + } +}; + +C.prototype.method(42, 'TC39',).next(); + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-args-trailing-comma-null.js new file mode 100644 index 0000000000..e926bf1519 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-args-trailing-comma-null.js @@ -0,0 +1,51 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/cls-expr-gen-meth.template +/*--- +description: A trailing comma after null should not increase the arguments.length (class expression generator method) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; + } +}; + +C.prototype.method(42, null,).next(); + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..1aef6d81a1 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-args-trailing-comma-single-args.js @@ -0,0 +1,50 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/cls-expr-gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (class expression generator method) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + *method() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; + } +}; + +C.prototype.method(42,).next(); + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..b8350f3254 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-args-trailing-comma-spread-operator.js @@ -0,0 +1,55 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/cls-expr-gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (class expression generator method) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +var C = class { + *method() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; + } +}; + +C.prototype.method(42, ...[1], ...arr,).next(); + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..b0cbac8aa0 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-args-trailing-comma-undefined.js @@ -0,0 +1,51 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/cls-expr-gen-meth.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (class expression generator method) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; + } +}; + +C.prototype.method(42, undefined,).next(); + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-static-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-static-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..bf3b368677 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-static-args-trailing-comma-multiple.js @@ -0,0 +1,51 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/cls-expr-gen-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (static class expression generator method) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + static *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; + } +}; + +C.method(42, 'TC39',).next(); + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-static-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-static-args-trailing-comma-null.js new file mode 100644 index 0000000000..0f36f0a3e8 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-static-args-trailing-comma-null.js @@ -0,0 +1,51 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/cls-expr-gen-meth-static.template +/*--- +description: A trailing comma after null should not increase the arguments.length (static class expression generator method) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + static *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; + } +}; + +C.method(42, null,).next(); + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-static-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-static-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..0fbd0feaa6 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-static-args-trailing-comma-single-args.js @@ -0,0 +1,50 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/cls-expr-gen-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (static class expression generator method) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + static *method() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; + } +}; + +C.method(42,).next(); + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-static-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-static-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..385b91cbb0 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-static-args-trailing-comma-spread-operator.js @@ -0,0 +1,55 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/cls-expr-gen-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (static class expression generator method) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +var C = class { + static *method() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; + } +}; + +C.method(42, ...[1], ...arr,).next(); + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-static-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-static-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..6da48e7783 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-gen-meth-static-args-trailing-comma-undefined.js @@ -0,0 +1,51 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/cls-expr-gen-meth-static.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (static class expression generator method) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + static *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; + } +}; + +C.method(42, undefined,).next(); + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-meth-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/cls-expr-meth-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..3ce5995992 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-meth-args-trailing-comma-multiple.js @@ -0,0 +1,49 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/cls-expr-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (class expression method) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; + } +}; + +C.prototype.method(42, 'TC39',); + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-meth-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/cls-expr-meth-args-trailing-comma-null.js new file mode 100644 index 0000000000..b90750d256 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-meth-args-trailing-comma-null.js @@ -0,0 +1,49 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/cls-expr-meth.template +/*--- +description: A trailing comma after null should not increase the arguments.length (class expression method) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; + } +}; + +C.prototype.method(42, null,); + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-meth-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/cls-expr-meth-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..565edee983 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-meth-args-trailing-comma-single-args.js @@ -0,0 +1,48 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/cls-expr-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (class expression method) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + method() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; + } +}; + +C.prototype.method(42,); + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-meth-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/cls-expr-meth-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..b5de137fb0 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-meth-args-trailing-comma-spread-operator.js @@ -0,0 +1,53 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/cls-expr-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (class expression method) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +var C = class { + method() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; + } +}; + +C.prototype.method(42, ...[1], ...arr,); + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-meth-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/cls-expr-meth-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..b109368ca1 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-meth-args-trailing-comma-undefined.js @@ -0,0 +1,49 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/cls-expr-meth.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (class expression method) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; + } +}; + +C.prototype.method(42, undefined,); + +// Stores a reference `ref` for case evaluation +var ref = C.prototype.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-meth-static-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/cls-expr-meth-static-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..f40b112d39 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-meth-static-args-trailing-comma-multiple.js @@ -0,0 +1,49 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/cls-expr-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (static class expression method) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + static method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; + } +}; + +C.method(42, 'TC39',); + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-meth-static-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/cls-expr-meth-static-args-trailing-comma-null.js new file mode 100644 index 0000000000..9dd835d53c --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-meth-static-args-trailing-comma-null.js @@ -0,0 +1,49 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/cls-expr-meth-static.template +/*--- +description: A trailing comma after null should not increase the arguments.length (static class expression method) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + static method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; + } +}; + +C.method(42, null,); + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-meth-static-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/cls-expr-meth-static-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..0ec9e3c32f --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-meth-static-args-trailing-comma-single-args.js @@ -0,0 +1,48 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/cls-expr-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (static class expression method) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + static method() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; + } +}; + +C.method(42,); + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-meth-static-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/cls-expr-meth-static-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..cc20dae198 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-meth-static-args-trailing-comma-spread-operator.js @@ -0,0 +1,53 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/cls-expr-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (static class expression method) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +var C = class { + static method() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; + } +}; + +C.method(42, ...[1], ...arr,); + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-meth-static-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/cls-expr-meth-static-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..72eb7b0373 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-meth-static-args-trailing-comma-undefined.js @@ -0,0 +1,49 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/cls-expr-meth-static.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (static class expression method) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + static method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; + } +}; + +C.method(42, undefined,); + +// Stores a reference `ref` for case evaluation +var ref = C.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..30263921b8 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-args-trailing-comma-multiple.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/cls-expr-private-gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (class expression private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [generators, class, class-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + * #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method(42, 'TC39',).next(); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-args-trailing-comma-null.js new file mode 100644 index 0000000000..be66c8cb0e --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-args-trailing-comma-null.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/cls-expr-private-gen-meth.template +/*--- +description: A trailing comma after null should not increase the arguments.length (class expression private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [generators, class, class-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + * #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method(42, null,).next(); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..386cc3cdbd --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-args-trailing-comma-single-args.js @@ -0,0 +1,51 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/cls-expr-private-gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (class expression private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [generators, class, class-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + * #method() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method(42,).next(); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..bbd54a77ef --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-args-trailing-comma-spread-operator.js @@ -0,0 +1,56 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/cls-expr-private-gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (class expression private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [generators, class, class-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +var C = class { + * #method() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method(42, ...[1], ...arr,).next(); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..63c0b2cf48 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-args-trailing-comma-undefined.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/cls-expr-private-gen-meth.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (class expression private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [generators, class, class-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + * #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method(42, undefined,).next(); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-static-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-static-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..1d9414d51d --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-static-args-trailing-comma-multiple.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/cls-expr-private-gen-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (static class expression private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [generators, class, class-static-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + static * #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method(42, 'TC39',).next(); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-static-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-static-args-trailing-comma-null.js new file mode 100644 index 0000000000..3004a677e5 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-static-args-trailing-comma-null.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/cls-expr-private-gen-meth-static.template +/*--- +description: A trailing comma after null should not increase the arguments.length (static class expression private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [generators, class, class-static-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + static * #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method(42, null,).next(); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-static-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-static-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..3db27dc9d2 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-static-args-trailing-comma-single-args.js @@ -0,0 +1,51 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/cls-expr-private-gen-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (static class expression private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [generators, class, class-static-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + static * #method() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method(42,).next(); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-static-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-static-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..7bef7101c0 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-static-args-trailing-comma-spread-operator.js @@ -0,0 +1,56 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/cls-expr-private-gen-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (static class expression private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [generators, class, class-static-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +var C = class { + static * #method() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method(42, ...[1], ...arr,).next(); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-static-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-static-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..2941427504 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-private-gen-meth-static-args-trailing-comma-undefined.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/cls-expr-private-gen-meth-static.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (static class expression private generator method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [generators, class, class-static-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + static * #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method(42, undefined,).next(); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..75c3fd6008 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-args-trailing-comma-multiple.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/cls-expr-private-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (class expression private method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [class, class-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method(42, 'TC39',); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-args-trailing-comma-null.js new file mode 100644 index 0000000000..63dfae4c7f --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-args-trailing-comma-null.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/cls-expr-private-meth.template +/*--- +description: A trailing comma after null should not increase the arguments.length (class expression private method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [class, class-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method(42, null,); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..e765abf38f --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-args-trailing-comma-single-args.js @@ -0,0 +1,51 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/cls-expr-private-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (class expression private method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [class, class-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + #method() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method(42,); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..be0e710490 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-args-trailing-comma-spread-operator.js @@ -0,0 +1,56 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/cls-expr-private-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (class expression private method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [class, class-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +var C = class { + #method() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method(42, ...[1], ...arr,); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..72921299be --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-args-trailing-comma-undefined.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/cls-expr-private-meth.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (class expression private method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [class, class-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; + } + + get method() { + return this.#method; + } +}; + +new C().method(42, undefined,); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-static-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-static-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..76d51727b0 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-static-args-trailing-comma-multiple.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/cls-expr-private-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (static class expression private method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [class, class-static-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + static #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method(42, 'TC39',); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-static-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-static-args-trailing-comma-null.js new file mode 100644 index 0000000000..8740be5a75 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-static-args-trailing-comma-null.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/cls-expr-private-meth-static.template +/*--- +description: A trailing comma after null should not increase the arguments.length (static class expression private method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [class, class-static-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + static #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method(42, null,); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-static-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-static-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..c57738eb10 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-static-args-trailing-comma-single-args.js @@ -0,0 +1,51 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/cls-expr-private-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (static class expression private method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [class, class-static-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + static #method() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method(42,); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-static-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-static-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..d558881f8c --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-static-args-trailing-comma-spread-operator.js @@ -0,0 +1,56 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/cls-expr-private-meth-static.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (static class expression private method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [class, class-static-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +var C = class { + static #method() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method(42, ...[1], ...arr,); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-static-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-static-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..d086cde834 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/cls-expr-private-meth-static-args-trailing-comma-undefined.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/cls-expr-private-meth-static.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (static class expression private method) +esid: sec-argument-lists-runtime-semantics-argumentlistevaluation +features: [class, class-static-methods-private] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var C = class { + static #method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; + } + + static get method() { + return this.#method; + } +}; + +C.method(42, undefined,); + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/func-decl-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/func-decl-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..7abaf595f2 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/func-decl-args-trailing-comma-multiple.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/func-decl.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (function declaration) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +function ref() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; +} + +ref(42, 'TC39',); + +assert.sameValue(callCount, 1, 'function invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/func-decl-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/func-decl-args-trailing-comma-null.js new file mode 100644 index 0000000000..6fad5d1790 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/func-decl-args-trailing-comma-null.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/func-decl.template +/*--- +description: A trailing comma after null should not increase the arguments.length (function declaration) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +function ref() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; +} + +ref(42, null,); + +assert.sameValue(callCount, 1, 'function invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/func-decl-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/func-decl-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..51dd22f9de --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/func-decl-args-trailing-comma-single-args.js @@ -0,0 +1,44 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/func-decl.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (function declaration) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +function ref() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; +} + +ref(42,); + +assert.sameValue(callCount, 1, 'function invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/func-decl-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/func-decl-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..440f108e6c --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/func-decl-args-trailing-comma-spread-operator.js @@ -0,0 +1,49 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/func-decl.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (function declaration) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +function ref() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; +} + +ref(42, ...[1], ...arr,); + +assert.sameValue(callCount, 1, 'function invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/func-decl-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/func-decl-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..a8e41aa8c7 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/func-decl-args-trailing-comma-undefined.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/func-decl.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (function declaration) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +function ref() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; +} + +ref(42, undefined,); + +assert.sameValue(callCount, 1, 'function invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/func-expr-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/func-expr-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..1da786248e --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/func-expr-args-trailing-comma-multiple.js @@ -0,0 +1,46 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/func-expr.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (function expression) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +var ref; +ref = function() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; +}; + +ref(42, 'TC39',); + +assert.sameValue(callCount, 1, 'function invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/func-expr-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/func-expr-args-trailing-comma-null.js new file mode 100644 index 0000000000..884f8678f5 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/func-expr-args-trailing-comma-null.js @@ -0,0 +1,46 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/func-expr.template +/*--- +description: A trailing comma after null should not increase the arguments.length (function expression) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +var ref; +ref = function() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; +}; + +ref(42, null,); + +assert.sameValue(callCount, 1, 'function invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/func-expr-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/func-expr-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..2a0eb9ef34 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/func-expr-args-trailing-comma-single-args.js @@ -0,0 +1,45 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/func-expr.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (function expression) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +var ref; +ref = function() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; +}; + +ref(42,); + +assert.sameValue(callCount, 1, 'function invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/func-expr-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/func-expr-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..44fe6aaba3 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/func-expr-args-trailing-comma-spread-operator.js @@ -0,0 +1,50 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/func-expr.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (function expression) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +var ref; +ref = function() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; +}; + +ref(42, ...[1], ...arr,); + +assert.sameValue(callCount, 1, 'function invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/func-expr-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/func-expr-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..125da8af4d --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/func-expr-args-trailing-comma-undefined.js @@ -0,0 +1,46 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/func-expr.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (function expression) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +var ref; +ref = function() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; +}; + +ref(42, undefined,); + +assert.sameValue(callCount, 1, 'function invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/gen-func-decl-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/gen-func-decl-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..dda181a561 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/gen-func-decl-args-trailing-comma-multiple.js @@ -0,0 +1,47 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/gen-func-decl.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (generator function declaration) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +function* ref() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; +} + +ref(42, 'TC39',).next(); + +assert.sameValue(callCount, 1, 'generator function invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/gen-func-decl-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/gen-func-decl-args-trailing-comma-null.js new file mode 100644 index 0000000000..692dc2bead --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/gen-func-decl-args-trailing-comma-null.js @@ -0,0 +1,47 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/gen-func-decl.template +/*--- +description: A trailing comma after null should not increase the arguments.length (generator function declaration) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +function* ref() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; +} + +ref(42, null,).next(); + +assert.sameValue(callCount, 1, 'generator function invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/gen-func-decl-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/gen-func-decl-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..d52b9511e2 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/gen-func-decl-args-trailing-comma-single-args.js @@ -0,0 +1,46 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/gen-func-decl.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (generator function declaration) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +function* ref() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; +} + +ref(42,).next(); + +assert.sameValue(callCount, 1, 'generator function invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/gen-func-decl-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/gen-func-decl-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..2902610c09 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/gen-func-decl-args-trailing-comma-spread-operator.js @@ -0,0 +1,51 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/gen-func-decl.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (generator function declaration) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +function* ref() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; +} + +ref(42, ...[1], ...arr,).next(); + +assert.sameValue(callCount, 1, 'generator function invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/gen-func-decl-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/gen-func-decl-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..d71738560d --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/gen-func-decl-args-trailing-comma-undefined.js @@ -0,0 +1,47 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/gen-func-decl.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (generator function declaration) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +function* ref() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; +} + +ref(42, undefined,).next(); + +assert.sameValue(callCount, 1, 'generator function invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/gen-func-expr-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/gen-func-expr-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..cf8011a2d5 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/gen-func-expr-args-trailing-comma-multiple.js @@ -0,0 +1,48 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/gen-func-expr.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (generator function expression) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +var ref; +ref = function*() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; +}; + +ref(42, 'TC39',).next(); + +assert.sameValue(callCount, 1, 'generator function invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/gen-func-expr-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/gen-func-expr-args-trailing-comma-null.js new file mode 100644 index 0000000000..353c546a5d --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/gen-func-expr-args-trailing-comma-null.js @@ -0,0 +1,48 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/gen-func-expr.template +/*--- +description: A trailing comma after null should not increase the arguments.length (generator function expression) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +var ref; +ref = function*() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; +}; + +ref(42, null,).next(); + +assert.sameValue(callCount, 1, 'generator function invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/gen-func-expr-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/gen-func-expr-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..2c9b1325a1 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/gen-func-expr-args-trailing-comma-single-args.js @@ -0,0 +1,47 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/gen-func-expr.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (generator function expression) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +var ref; +ref = function*() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; +}; + +ref(42,).next(); + +assert.sameValue(callCount, 1, 'generator function invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/gen-func-expr-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/gen-func-expr-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..adad4b86ad --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/gen-func-expr-args-trailing-comma-spread-operator.js @@ -0,0 +1,52 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/gen-func-expr.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (generator function expression) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +var ref; +ref = function*() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; +}; + +ref(42, ...[1], ...arr,).next(); + +assert.sameValue(callCount, 1, 'generator function invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/gen-func-expr-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/gen-func-expr-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..eaf9e6b91b --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/gen-func-expr-args-trailing-comma-undefined.js @@ -0,0 +1,48 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/gen-func-expr.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (generator function expression) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +// Stores a reference `ref` for case evaluation +var ref; +ref = function*() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; +}; + +ref(42, undefined,).next(); + +assert.sameValue(callCount, 1, 'generator function invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/gen-meth-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/gen-meth-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..243eee0936 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/gen-meth-args-trailing-comma-multiple.js @@ -0,0 +1,51 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (generator method) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var obj = { + *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; + } +}; + +obj.method(42, 'TC39',).next(); + +// Stores a reference `ref` for case evaluation +var ref = obj.method; + +assert.sameValue(callCount, 1, 'generator method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/gen-meth-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/gen-meth-args-trailing-comma-null.js new file mode 100644 index 0000000000..95dd6f1e44 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/gen-meth-args-trailing-comma-null.js @@ -0,0 +1,51 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/gen-meth.template +/*--- +description: A trailing comma after null should not increase the arguments.length (generator method) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var obj = { + *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; + } +}; + +obj.method(42, null,).next(); + +// Stores a reference `ref` for case evaluation +var ref = obj.method; + +assert.sameValue(callCount, 1, 'generator method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/gen-meth-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/gen-meth-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..11dc64ead7 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/gen-meth-args-trailing-comma-single-args.js @@ -0,0 +1,50 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (generator method) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var obj = { + *method() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; + } +}; + +obj.method(42,).next(); + +// Stores a reference `ref` for case evaluation +var ref = obj.method; + +assert.sameValue(callCount, 1, 'generator method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/gen-meth-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/gen-meth-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..e481dd7a1e --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/gen-meth-args-trailing-comma-spread-operator.js @@ -0,0 +1,55 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/gen-meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (generator method) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +var obj = { + *method() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; + } +}; + +obj.method(42, ...[1], ...arr,).next(); + +// Stores a reference `ref` for case evaluation +var ref = obj.method; + +assert.sameValue(callCount, 1, 'generator method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/gen-meth-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/gen-meth-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..048712a34b --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/gen-meth-args-trailing-comma-undefined.js @@ -0,0 +1,51 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/gen-meth.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (generator method) +esid: sec-arguments-exotic-objects +features: [generators] +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var obj = { + *method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; + } +}; + +obj.method(42, undefined,).next(); + +// Stores a reference `ref` for case evaluation +var ref = obj.method; + +assert.sameValue(callCount, 1, 'generator method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/Symbol.iterator.js b/js/src/tests/test262/language/arguments-object/mapped/Symbol.iterator.js new file mode 100644 index 0000000000..72d0534c36 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/Symbol.iterator.js @@ -0,0 +1,22 @@ +// Copyright (C) 2014 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 9.4.4.7 S22 +description: > + Mapped arguments exotic objects should implement the Array iterator + protocol. +includes: [propertyHelper.js] +flags: [noStrict] +features: [Symbol.iterator] +---*/ + +(function() { + verifyProperty(arguments, Symbol.iterator, { + value: [][Symbol.iterator], + writable: true, + enumerable: false, + configurable: true, + }); +}()); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/browser.js b/js/src/tests/test262/language/arguments-object/mapped/browser.js new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/browser.js diff --git a/js/src/tests/test262/language/arguments-object/mapped/enumerable-configurable-accessor-descriptor.js b/js/src/tests/test262/language/arguments-object/mapped/enumerable-configurable-accessor-descriptor.js new file mode 100644 index 0000000000..bb2a5cb390 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/enumerable-configurable-accessor-descriptor.js @@ -0,0 +1,46 @@ +// Copyright (C) 2020 Alexey Shvayka. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-arguments-exotic-objects-defineownproperty-p-desc +description: > + Index gets unmapped when redefined with accessor. Unmapped index is created. +info: | + [[DefineOwnProperty]] ( P, Desc ) + + [...] + 6. Let allowed be ? OrdinaryDefineOwnProperty(args, P, newArgDesc). + 7. If allowed is false, return false. + 8. If isMapped is true, then + a. If IsAccessorDescriptor(Desc) is true, then + i. Call map.[[Delete]](P). + [...] + 9. Return true. +flags: [noStrict] +---*/ + +(function(a) { + let setCalls = 0; + Object.defineProperty(arguments, "0", { + set(_v) { setCalls += 1; }, + enumerable: true, + configurable: true, + }); + + arguments[0] = "foo"; + + assert.sameValue(setCalls, 1); + assert.sameValue(a, 0); + assert.sameValue(arguments[0], undefined); + + + Object.defineProperty(arguments, "1", { + get: () => "bar", + enumerable: true, + configurable: true, + }); + + assert.sameValue(arguments[1], "bar"); +})(0); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-1.js b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-1.js new file mode 100644 index 0000000000..67c909fb28 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-1.js @@ -0,0 +1,19 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Mapped arguments object with non-configurable property +description: > + Mapped value is not changed when property was made non-configurable. +flags: [noStrict] +---*/ + +function argumentsNonConfigurable(a) { + Object.defineProperty(arguments, "0", {configurable: false}); + + assert.sameValue(a, 1); + assert.sameValue(arguments[0], 1); +} +argumentsNonConfigurable(1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-2.js b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-2.js new file mode 100644 index 0000000000..12cbcb5170 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-2.js @@ -0,0 +1,21 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Mapped arguments object with non-configurable property +description: > + Mapping works when property is non-configurable, variable is + changed with SetMutableBinding. +flags: [noStrict] +---*/ + +function argumentsAndSetMutableBinding(a) { + Object.defineProperty(arguments, "0", {configurable: false}); + + a = 2; + assert.sameValue(a, 2); + assert.sameValue(arguments[0], 2); +} +argumentsAndSetMutableBinding(1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-3.js b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-3.js new file mode 100644 index 0000000000..2cedf2ae79 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-3.js @@ -0,0 +1,21 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Mapped arguments object with non-configurable property +description: > + Mapping works when property is non-configurable, arguments property + is changed with [[DefineOwnProperty]]. +flags: [noStrict] +---*/ + +function argumentsAndDefineOwnProperty(a) { + Object.defineProperty(arguments, "0", {configurable: false}); + + Object.defineProperty(arguments, "0", {value: 2}); + assert.sameValue(a, 2); + assert.sameValue(arguments[0], 2); +} +argumentsAndDefineOwnProperty(1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-4.js b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-4.js new file mode 100644 index 0000000000..1f26fc78c5 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-4.js @@ -0,0 +1,21 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Mapped arguments object with non-configurable property +description: > + Mapping works when property is non-configurable, arguments property + is changed with [[Set]]. +flags: [noStrict] +---*/ + +function argumentsAndSet(a) { + Object.defineProperty(arguments, "0", {configurable: false}); + + arguments[0] = 2; + assert.sameValue(a, 2); + assert.sameValue(arguments[0], 2); +} +argumentsAndSet(1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-delete-1.js b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-delete-1.js new file mode 100644 index 0000000000..ac0eac446e --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-delete-1.js @@ -0,0 +1,21 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Mapped arguments object with non-configurable property +description: > + Mapping works when property is non-configurable, arguments property + was not deleted. [[Delete]] operation returns false. +flags: [noStrict] +---*/ + +function argumentsAndDelete(a) { + Object.defineProperty(arguments, "0", {configurable: false}); + + assert.sameValue(delete arguments[0], false); + assert.sameValue(a, 1); + assert.sameValue(arguments[0], 1); +} +argumentsAndDelete(1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-delete-2.js b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-delete-2.js new file mode 100644 index 0000000000..f4df9a1c20 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-delete-2.js @@ -0,0 +1,26 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Mapped arguments object with non-configurable property +description: > + Mapping works when property is non-configurable, arguments property + was not deleted. Variable is changed with SetMutableBinding. +flags: [noStrict] +---*/ + +function argumentsAndDeleteSetMutableBinding(a) { + Object.defineProperty(arguments, "0", {configurable: false}); + + // Precondition: Delete is unsuccessful and doesn't affect mapping. + assert.sameValue(delete arguments[0], false); + assert.sameValue(a, 1); + assert.sameValue(arguments[0], 1); + + a = 2; + assert.sameValue(a, 2); + assert.sameValue(arguments[0], 2); +} +argumentsAndDeleteSetMutableBinding(1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-delete-3.js b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-delete-3.js new file mode 100644 index 0000000000..e1b8775385 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-delete-3.js @@ -0,0 +1,27 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Mapped arguments object with non-configurable property +description: > + Mapping works when property is non-configurable, arguments property + was not deleted. Arguments property is changed with + [[DefineOwnProperty]]. +flags: [noStrict] +---*/ + +function argumentsAndDeleteDefineOwnProperty(a) { + Object.defineProperty(arguments, "0", {configurable: false}); + + // Precondition: Delete is unsuccessful and doesn't affect mapping. + assert.sameValue(delete arguments[0], false); + assert.sameValue(a, 1); + assert.sameValue(arguments[0], 1); + + Object.defineProperty(arguments, "0", {value: 2}); + assert.sameValue(a, 2); + assert.sameValue(arguments[0], 2); +} +argumentsAndDeleteDefineOwnProperty(1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-delete-4.js b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-delete-4.js new file mode 100644 index 0000000000..21dfa0d645 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-delete-4.js @@ -0,0 +1,27 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Mapped arguments object with non-configurable property +description: > + Mapping works when property is non-configurable, arguments property + was not deleted. Arguments property is changed with + [[Set]]. +flags: [noStrict] +---*/ + +function argumentsAndDeleteSet(a) { + Object.defineProperty(arguments, "0", {configurable: false}); + + // Precondition: Delete is unsuccessful and doesn't affect mapping. + assert.sameValue(delete arguments[0], false); + assert.sameValue(a, 1); + assert.sameValue(arguments[0], 1); + + arguments[0] = 2; + assert.sameValue(a, 2); + assert.sameValue(arguments[0], 2); +} +argumentsAndDeleteSet(1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-nonwritable-1.js b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-nonwritable-1.js new file mode 100644 index 0000000000..2b964aa3db --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-nonwritable-1.js @@ -0,0 +1,26 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Mapped arguments object with non-configurable property +description: > + Mapped arguments property is changed to non-configurable and + non-writable. Perform property attribute changes with a single + [[DefineOwnProperty]] call. Mapped values are unchanged, mapping + itself is removed. +flags: [noStrict] +---*/ + +function argumentsNonConfigurableAndNonWritable(a) { + Object.defineProperty(arguments, "0", {configurable: false, writable: false}); + assert.sameValue(a, 1); + assert.sameValue(arguments[0], 1); + + // Postcondition: Arguments mapping is removed. + a = 2; + assert.sameValue(a, 2); + assert.sameValue(arguments[0], 1); +} +argumentsNonConfigurableAndNonWritable(1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-nonwritable-2.js b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-nonwritable-2.js new file mode 100644 index 0000000000..cf93842382 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-nonwritable-2.js @@ -0,0 +1,27 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Mapped arguments object with non-configurable property +description: > + Mapped arguments property is changed to non-configurable and + non-writable. Perform property attribute changes with two + consecutive [[DefineOwnProperty]] calls. Mapped values are + unchanged, mapping itself is removed. +flags: [noStrict] +---*/ + +function argumentsNonConfigurableThenNonWritable(a) { + Object.defineProperty(arguments, "0", {configurable: false}); + Object.defineProperty(arguments, "0", {writable: false}); + assert.sameValue(a, 1); + assert.sameValue(arguments[0], 1); + + // Postcondition: Arguments mapping is removed. + a = 2; + assert.sameValue(a, 2); + assert.sameValue(arguments[0], 1); +} +argumentsNonConfigurableThenNonWritable(1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-nonwritable-3.js b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-nonwritable-3.js new file mode 100644 index 0000000000..243e8b3958 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-nonwritable-3.js @@ -0,0 +1,30 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Mapped arguments object with non-configurable property +description: > + Mapped arguments property is changed to non-configurable and + non-writable. Perform property attribute changes with two + [[DefineOwnProperty]] calls. Add intervening call to + SetMutableBinding. +flags: [noStrict] +---*/ + +function argumentsNonConfigurableThenNonWritableWithInterveningSetMutableBinding(a) { + Object.defineProperty(arguments, "0", {configurable: false}); + a = 2; + Object.defineProperty(arguments, "0", {writable: false}); + assert.sameValue(a, 2); + // `arguments[0] === 1` per ES2015, Rev 38, April 14, 2015 Final Draft. + // Specification bug: https://bugs.ecmascript.org/show_bug.cgi?id=4371 + assert.sameValue(arguments[0], 2); + + // Postcondition: Arguments mapping is removed. + a = 3; + assert.sameValue(a, 3); + assert.sameValue(arguments[0], 2); +} +argumentsNonConfigurableThenNonWritableWithInterveningSetMutableBinding(1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-nonwritable-4.js b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-nonwritable-4.js new file mode 100644 index 0000000000..77cb38fe5b --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-nonwritable-4.js @@ -0,0 +1,27 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Mapped arguments object with non-configurable property +description: > + Mapped arguments property is changed to non-configurable and + non-writable. Perform property attribute changes with two + [[DefineOwnProperty]] calls. Add intervening call to [[Set]]. +flags: [noStrict] +---*/ + +function argumentsNonConfigurableThenNonWritableWithInterveningSet(a) { + Object.defineProperty(arguments, "0", {configurable: false}); + arguments[0] = 2; + Object.defineProperty(arguments, "0", {writable: false}); + assert.sameValue(a, 2); + assert.sameValue(arguments[0], 2); + + // Postcondition: Arguments mapping is removed. + a = 3; + assert.sameValue(a, 3); + assert.sameValue(arguments[0], 2); +} +argumentsNonConfigurableThenNonWritableWithInterveningSet(1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-nonwritable-5.js b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-nonwritable-5.js new file mode 100644 index 0000000000..450c6bb79e --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-nonwritable-5.js @@ -0,0 +1,28 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Mapped arguments object with non-configurable property +description: > + Mapped arguments property is changed to non-configurable and + non-writable. Perform property attribute changes with two + [[DefineOwnProperty]] calls. Add intervening call to + [[DefineOwnProperty]]. +flags: [noStrict] +---*/ + +function argumentsNonConfigurableThenNonWritableWithDefineOwnProperty(a) { + Object.defineProperty(arguments, "0", {configurable: false}); + Object.defineProperty(arguments, "0", {value: 2}); + Object.defineProperty(arguments, "0", {writable: false}); + assert.sameValue(a, 2); + assert.sameValue(arguments[0], 2); + + // Postcondition: Arguments mapping is removed. + a = 3; + assert.sameValue(a, 3); + assert.sameValue(arguments[0], 2); +} +argumentsNonConfigurableThenNonWritableWithDefineOwnProperty(1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-strict-delete-1.js b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-strict-delete-1.js new file mode 100644 index 0000000000..4255e6ae6a --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-strict-delete-1.js @@ -0,0 +1,23 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Mapped arguments object with non-configurable property +description: > + Mapping works when property is non-configurable, arguments property + was not deleted. [[Delete]] operations throws TypeError if called + from strict-mode code. +flags: [noStrict] +---*/ + +function argumentsAndStrictDelete(a) { + Object.defineProperty(arguments, "0", {configurable: false}); + + var args = arguments; + assert.throws(TypeError, function() { "use strict"; delete args[0]; }); + assert.sameValue(a, 1); + assert.sameValue(arguments[0], 1); +} +argumentsAndStrictDelete(1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-strict-delete-2.js b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-strict-delete-2.js new file mode 100644 index 0000000000..1786e32a2c --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-strict-delete-2.js @@ -0,0 +1,28 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Mapped arguments object with non-configurable property +description: > + Mapping works when property is non-configurable, arguments property + was not deleted. [[Delete]] operations throws TypeError if called + from strict-mode code. Variable is changed with SetMutableBinding. +flags: [noStrict] +---*/ + +function argumentsAndStrictDeleteSetMutableBinding(a) { + Object.defineProperty(arguments, "0", {configurable: false}); + + // Precondition: Delete is unsuccessful and doesn't affect mapping. + var args = arguments; + assert.throws(TypeError, function() { "use strict"; delete args[0]; }); + assert.sameValue(a, 1); + assert.sameValue(arguments[0], 1); + + a = 2; + assert.sameValue(a, 2); + assert.sameValue(arguments[0], 2); +} +argumentsAndStrictDeleteSetMutableBinding(1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-strict-delete-3.js b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-strict-delete-3.js new file mode 100644 index 0000000000..5f328c2ebd --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-strict-delete-3.js @@ -0,0 +1,29 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Mapped arguments object with non-configurable property +description: > + Mapping works when property is non-configurable, arguments property + was not deleted. [[Delete]] operations throws TypeError if called + from strict-mode code. Arguments property is changed with + [[DefineOwnProperty]]. +flags: [noStrict] +---*/ + +function argumentsAndStrictDeleteDefineOwnProperty(a) { + Object.defineProperty(arguments, "0", {configurable: false}); + + // Precondition: Delete is unsuccessful and doesn't affect mapping. + var args = arguments; + assert.throws(TypeError, function() { "use strict"; delete args[0]; }); + assert.sameValue(a, 1); + assert.sameValue(arguments[0], 1); + + Object.defineProperty(arguments, "0", {value: 2}); + assert.sameValue(a, 2); + assert.sameValue(arguments[0], 2); +} +argumentsAndStrictDeleteDefineOwnProperty(1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-strict-delete-4.js b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-strict-delete-4.js new file mode 100644 index 0000000000..bb2440ee8c --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonconfigurable-strict-delete-4.js @@ -0,0 +1,28 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Mapped arguments object with non-configurable property +description: > + Mapping works when property is non-configurable, arguments property + was not deleted. [[Delete]] operations throws TypeError if called + from strict-mode code. Arguments property is changed with [[Set]]. +flags: [noStrict] +---*/ + +function argumentsAndStrictDeleteSet(a) { + Object.defineProperty(arguments, "0", {configurable: false}); + + // Precondition: Delete is unsuccessful and doesn't affect mapping. + var args = arguments; + assert.throws(TypeError, function() { "use strict"; delete args[0]; }); + assert.sameValue(a, 1); + assert.sameValue(arguments[0], 1); + + arguments[0] = 2; + assert.sameValue(a, 2); + assert.sameValue(arguments[0], 2); +} +argumentsAndStrictDeleteSet(1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonwritable-nonconfigurable-1.js b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonwritable-nonconfigurable-1.js new file mode 100644 index 0000000000..7b6f7df047 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonwritable-nonconfigurable-1.js @@ -0,0 +1,27 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Mapped arguments object with non-configurable property +description: > + Mapped arguments property is changed to non-writable and + non-configurable. Perform property attribute changes with two + consecutive [[DefineOwnProperty]] calls. Mapped values are + unchanged, mapping itself is removed. +flags: [noStrict] +---*/ + +function argumentsNonWritableThenNonConfigurable(a) { + Object.defineProperty(arguments, "0", {writable: false}); + Object.defineProperty(arguments, "0", {configurable: false}); + assert.sameValue(a, 1); + assert.sameValue(arguments[0], 1); + + // Postcondition: Arguments mapping is removed. + a = 2; + assert.sameValue(a, 2); + assert.sameValue(arguments[0], 1); +} +argumentsNonWritableThenNonConfigurable(1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonwritable-nonconfigurable-2.js b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonwritable-nonconfigurable-2.js new file mode 100644 index 0000000000..86fc445420 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonwritable-nonconfigurable-2.js @@ -0,0 +1,28 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Mapped arguments object with non-configurable property +description: > + Mapped arguments property is changed to non-writable and + non-configurable. Perform property attribute changes with two + [[DefineOwnProperty]] calls. Add intervening call to + SetMutableBinding. +flags: [noStrict] +---*/ + +function argumentsNonWritableThenNonConfigurableWithInterveningSetMutableBinding(a) { + Object.defineProperty(arguments, "0", {writable: false}); + a = 2; + Object.defineProperty(arguments, "0", {configurable: false}); + assert.sameValue(a, 2); + assert.sameValue(arguments[0], 1); + + // Postcondition: Arguments mapping is removed. + a = 3; + assert.sameValue(a, 3); + assert.sameValue(arguments[0], 1); +} +argumentsNonWritableThenNonConfigurableWithInterveningSetMutableBinding(1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonwritable-nonconfigurable-3.js b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonwritable-nonconfigurable-3.js new file mode 100644 index 0000000000..7ab519c589 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonwritable-nonconfigurable-3.js @@ -0,0 +1,27 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Mapped arguments object with non-configurable property +description: > + Mapped arguments property is changed to non-writable and + non-configurable. Perform property attribute changes with two + [[DefineOwnProperty]] calls. Add intervening call to [[Set]]. +flags: [noStrict] +---*/ + +function argumentsNonWritableThenNonConfigurableWithInterveningSet(a) { + Object.defineProperty(arguments, "0", {writable: false}); + arguments[0] = 2; + Object.defineProperty(arguments, "0", {configurable: false}); + assert.sameValue(a, 1); + assert.sameValue(arguments[0], 1); + + // Postcondition: Arguments mapping is removed. + a = 3; + assert.sameValue(a, 3); + assert.sameValue(arguments[0], 1); +} +argumentsNonWritableThenNonConfigurableWithInterveningSet(1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonwritable-nonconfigurable-4.js b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonwritable-nonconfigurable-4.js new file mode 100644 index 0000000000..5c3033d9c7 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/mapped-arguments-nonwritable-nonconfigurable-4.js @@ -0,0 +1,28 @@ +// Copyright (C) 2015 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +info: Mapped arguments object with non-configurable property +description: > + Mapped arguments property is changed to non-writable and + non-configurable. Perform property attribute changes with two + [[DefineOwnProperty]] calls. Add intervening call to + [[DefineOwnProperty]]. +flags: [noStrict] +---*/ + +function argumentsNonWritableThenNonConfigurableWithInterveningDefineOwnProperty(a) { + Object.defineProperty(arguments, "0", {writable: false}); + Object.defineProperty(arguments, "0", {value: 2}); + Object.defineProperty(arguments, "0", {configurable: false}); + assert.sameValue(a, 1); + assert.sameValue(arguments[0], 2); + + // Postcondition: Arguments mapping is removed. + a = 3; + assert.sameValue(a, 3); + assert.sameValue(arguments[0], 2); +} +argumentsNonWritableThenNonConfigurableWithInterveningDefineOwnProperty(1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-descriptors-basic.js b/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-descriptors-basic.js new file mode 100644 index 0000000000..04ed41e285 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-descriptors-basic.js @@ -0,0 +1,25 @@ +// Copyright (C) 2017 Caio Lima. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Mapped arguments object with non-configurable property property descriptor behavior +info: | + Descriptor of a mapped value is updated when property is made non-configurable. +flags: [noStrict] +esid: sec-arguments-exotic-objects-defineownproperty-p-desc +includes: [propertyHelper.js] +---*/ + +function argumentsNonConfigurable(a) { + Object.defineProperty(arguments, "0", {configurable: false}); + + verifyProperty(arguments, "0", { + value: 1, + writable: true, + enumerable: true, + configurable: false, + }); +} +argumentsNonConfigurable(1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-descriptors-define-failure.js b/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-descriptors-define-failure.js new file mode 100644 index 0000000000..0552fa5d5b --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-descriptors-define-failure.js @@ -0,0 +1,45 @@ +// Copyright (C) 2020 Alexey Shvayka. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-arguments-exotic-objects-defineownproperty-p-desc +description: > + OrdinaryDefineOwnProperty returning `false` doesn't leave `arguments` in a + corrupted state, for both mapped and unmapped indices. +info: | + [[DefineOwnProperty]] ( P, Desc ) + + [...] + 6. Let allowed be ? OrdinaryDefineOwnProperty(args, P, newArgDesc). + 7. If allowed is false, return false. +flags: [noStrict] +---*/ + +(function(a) { + Object.defineProperty(arguments, "0", {configurable: false}); + + assert.throws(TypeError, () => { + Object.defineProperty(arguments, "0", {configurable: true}); + }); + + a = 2; + assert.sameValue(arguments[0], 2); + + + Object.defineProperty(arguments, "1", { + get: () => 3, + configurable: false, + }); + + assert.throws(TypeError, () => { + Object.defineProperty(arguments, "1", {value: "foo"}); + }); + + assert.sameValue(arguments[1], 3); + assert.throws(TypeError, () => { + "use strict"; + delete arguments[1]; + }); +})(0); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-descriptors-set-value-by-arguments.js b/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-descriptors-set-value-by-arguments.js new file mode 100644 index 0000000000..35f2c7b4ae --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-descriptors-set-value-by-arguments.js @@ -0,0 +1,31 @@ +// Copyright (C) 2017 Caio Lima. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Mapped arguments property descriptor change with non-configurable property +info: | + Mapping keep working when property is set to non-configurable and its + value is changed using arguments[i] where "i" is the argument index. +flags: [noStrict] +esid: sec-arguments-exotic-objects-defineownproperty-p-desc +includes: [propertyHelper.js] +---*/ + +function argumentsAndSetByIndex(a) { + Object.defineProperty(arguments, "0", {configurable: false}); + + arguments[0] = 2; + + assert.sameValue(a, 2); + + verifyProperty(arguments, "0", { + value: 2, + writable: true, + enumerable: true, + configurable: false, + }); +} +argumentsAndSetByIndex(1); + + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-descriptors-set-value-with-define-property.js b/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-descriptors-set-value-with-define-property.js new file mode 100644 index 0000000000..e6a846ecc7 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-descriptors-set-value-with-define-property.js @@ -0,0 +1,31 @@ +// Copyright (C) 2017 Caio Lima. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Mapped arguments property descriptor change with non-configurable property +info: | + Mapping keep working when property is set to non-configurable and its + value is changed using [[DefineOwnProperty]]. +flags: [noStrict] +esid: sec-arguments-exotic-objects-defineownproperty-p-desc +includes: [propertyHelper.js] +---*/ + +function setArgumentValueWithDefineOwnProperty(a) { + Object.defineProperty(arguments, "0", {configurable: false}); + + Object.defineProperty(arguments, "0", {value: 2}); + + assert.sameValue(a, 2); + + verifyProperty(arguments, "0", { + value: 2, + writable: true, + enumerable: true, + configurable: false, + }); +} +setArgumentValueWithDefineOwnProperty(1); + + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-descriptors-with-param-assign.js b/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-descriptors-with-param-assign.js new file mode 100644 index 0000000000..bd74d1a9fd --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-descriptors-with-param-assign.js @@ -0,0 +1,29 @@ +// Copyright (C) 2017 Caio Lima. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Property descriptor of mapped arguments object with non-configurable property +info: | + Mapping keep working when property is set to non-configurable, and its + descriptor needs to change properly. +flags: [noStrict] +esid: sec-arguments-exotic-objects-defineownproperty-p-desc +includes: [propertyHelper.js] +---*/ + +function argumentsAndSetMutableBinding(a) { + Object.defineProperty(arguments, "0", {configurable: false}); + + a = 2; + + verifyProperty(arguments, "0", { + value: 2, + writable: true, + enumerable: true, + configurable: false, + }); +} +argumentsAndSetMutableBinding(1); + + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-nonenumerable-nonwritable-descriptors-basic.js b/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-nonenumerable-nonwritable-descriptors-basic.js new file mode 100644 index 0000000000..e05d630b5a --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-nonenumerable-nonwritable-descriptors-basic.js @@ -0,0 +1,30 @@ +// Copyright (C) 2017 Caio Lima. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Mapped arguments property descriptor change with non-configurable, non-enumerable and non-writable property +info: | + Mapping stop working when property is set to non-writable. The + descriptor's enumerable property is the one set before the mapping removal. +flags: [noStrict] +esid: sec-arguments-exotic-objects-defineownproperty-p-desc +includes: [propertyHelper.js] +---*/ + +function fn(a) { + Object.defineProperty(arguments, "0", {configurable: false, enumerable: false, writable: false}); + + // Postcondition: Arguments mapping is removed. + a = 2; + + verifyProperty(arguments, "0", { + value: 1, + writable: false, + enumerable: false, + configurable: false, + }); +} +fn(1); + + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-nonenumerable-nonwritable-descriptors-set-by-arguments.js b/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-nonenumerable-nonwritable-descriptors-set-by-arguments.js new file mode 100644 index 0000000000..ad5f0fdee6 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-nonenumerable-nonwritable-descriptors-set-by-arguments.js @@ -0,0 +1,42 @@ +// Copyright (C) 2017 Caio Lima. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Mapped arguments property descriptor change to non-configurable, non-enumerable and non-writable +info: | + Change the descriptor using [[DefineOwnProperty]] to {configurable: false, enumerable: false}, + set arguments[0] = 2 and then change property descriptor to {writable: false}. + The descriptor's enumerable property is the one set before the mapping removal. +flags: [noStrict] +esid: sec-arguments-exotic-objects-defineownproperty-p-desc +includes: [propertyHelper.js] +---*/ + +function fn(a) { + Object.defineProperty(arguments, "0", {configurable: false, enumerable: false}); + arguments[0] = 2; + Object.defineProperty(arguments, "0", {writable: false}); + + assert.sameValue(a, 2); + + verifyProperty(arguments, "0", { + value: 2, + writable: false, + enumerable: false, + configurable: false, + }); + + // Postcondition: Arguments mapping is removed. + a = 3; + + verifyProperty(arguments, "0", { + value: 2, + writable: false, + enumerable: false, + configurable: false, + }); +} +fn(1); + + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-nonenumerable-nonwritable-descriptors-set-by-param.js b/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-nonenumerable-nonwritable-descriptors-set-by-param.js new file mode 100644 index 0000000000..358a00aa29 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-nonenumerable-nonwritable-descriptors-set-by-param.js @@ -0,0 +1,41 @@ +// Copyright (C) 2017 Caio Lima. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Mapped arguments property descriptor change to non-configurable, non-enumerable and non-writable +info: | + Change the descriptor using [[DefineOwnProperty]] to + {configurable: false, enumerable: false}, set a = 2 and then + change property descriptor to {writable: false}. The descriptor's enumerable + property need to be the one set before the mapping removal. +flags: [noStrict] +esid: sec-arguments-exotic-objects-defineownproperty-p-desc +includes: [propertyHelper.js] +---*/ + +function fn(a) { + Object.defineProperty(arguments, "0", {configurable: false, enumerable: false}); + a = 2; + Object.defineProperty(arguments, "0", {writable: false}); + + verifyProperty(arguments, "0", { + value: 2, + writable: false, + enumerable: false, + configurable: false, + }); + + // Postcondition: Arguments mapping is removed. + a = 3; + + verifyProperty(arguments, "0", { + value: 2, + writable: false, + enumerable: false, + configurable: false, + }); +} +fn(1); + + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-nonwritable-descriptors-basic.js b/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-nonwritable-descriptors-basic.js new file mode 100644 index 0000000000..0f8c003a77 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-nonwritable-descriptors-basic.js @@ -0,0 +1,31 @@ +// Copyright (C) 2017 Caio Lima. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Mapped arguments property descriptor change with non-configurable and non-writable property +info: | + Mapping stop working when property is set to non-writable. The + descriptor's value need to be the one set before the property be configured as + writable: false. +flags: [noStrict] +esid: sec-arguments-exotic-objects-defineownproperty-p-desc +includes: [propertyHelper.js] +---*/ + +function fn(a) { + Object.defineProperty(arguments, "0", {configurable: false, writable: false}); + + // Postcondition: Arguments mapping is removed. + a = 2; + + verifyProperty(arguments, "0", { + value: 1, + writable: false, + enumerable: true, + configurable: false, + }); +} +fn(1); + + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-nonwritable-descriptors-define-property-consecutive.js b/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-nonwritable-descriptors-define-property-consecutive.js new file mode 100644 index 0000000000..15fa2262bd --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-nonwritable-descriptors-define-property-consecutive.js @@ -0,0 +1,39 @@ +// Copyright (C) 2017 Caio Lima. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Mapped arguments property descriptor change with non-configurable and non-writable property +info: | + Mapping stop working when property is set to non-writable. Change the + descriptor with two [[DefineOwnProperty]] calls. The descriptor's value need to be + the one set before the property be configured as writable: false. +flags: [noStrict] +esid: sec-arguments-exotic-objects-defineownproperty-p-desc +includes: [propertyHelper.js] +---*/ + +function fn(a) { + Object.defineProperty(arguments, "0", {configurable: false}); + Object.defineProperty(arguments, "0", {writable: false}); + + verifyProperty(arguments, "0", { + value: 1, + writable: false, + enumerable: true, + configurable: false, + }); + + // Postcondition: Arguments mapping is removed. + a = 2; + + verifyProperty(arguments, "0", { + value: 1, + writable: false, + enumerable: true, + configurable: false, + }); +} +fn(1); + + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-nonwritable-descriptors-set-by-arguments.js b/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-nonwritable-descriptors-set-by-arguments.js new file mode 100644 index 0000000000..cb9bbc5ef0 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-nonwritable-descriptors-set-by-arguments.js @@ -0,0 +1,44 @@ +// Copyright (C) 2017 Caio Lima. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Mapped arguments property descriptor change to non-configurable and non-writable +info: | + Mapping just stop working when property is set to non-writable. Change the + descriptor using [[DefineOwnProperty]] to {configurable: false}, set arguments[0] = 2 + and then change property descriptor to {writable: false}. + The descriptor's value need to be the one set before the property be + configured as {writable: false}. +flags: [noStrict] +esid: sec-arguments-exotic-objects-defineownproperty-p-desc +includes: [propertyHelper.js] +---*/ + +function fn(a) { + Object.defineProperty(arguments, "0", {configurable: false}); + arguments[0] = 2; + Object.defineProperty(arguments, "0", {writable: false}); + + assert.sameValue(a, 2) + + verifyProperty(arguments, "0", { + value: 2, + writable: false, + enumerable: true, + configurable: false, + }); + + // Postcondition: Arguments mapping is removed. + a = 3; + + verifyProperty(arguments, "0", { + value: 2, + writable: false, + enumerable: true, + configurable: false, + }); +} +fn(1); + + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-nonwritable-descriptors-set-by-param.js b/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-nonwritable-descriptors-set-by-param.js new file mode 100644 index 0000000000..ba9c4e855b --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/nonconfigurable-nonwritable-descriptors-set-by-param.js @@ -0,0 +1,41 @@ +// Copyright (C) 2017 Caio Lima. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Mapped arguments property descriptor change to non-configurable and non-writable +info: | + Mapping just stop working when property is set to non-writable. Change the + descriptor using [[DefineOwnProperty]] to {configurable: false}, set a = 2 and then + change property descriptor to {writable: false}. The descriptor's value is + the one set before the property be configured as {writable: false}. +flags: [noStrict] +esid: sec-arguments-exotic-objects-defineownproperty-p-desc +includes: [propertyHelper.js] +---*/ + +function fn(a) { + Object.defineProperty(arguments, "0", {configurable: false}); + a = 2; + Object.defineProperty(arguments, "0", {writable: false}); + + verifyProperty(arguments, "0", { + value: 2, + writable: false, + enumerable: true, + configurable: false, + }); + + // Postcondition: Arguments mapping is removed. + a = 3; + + verifyProperty(arguments, "0", { + value: 2, + writable: false, + enumerable: true, + configurable: false, + }); +} +fn(1); + + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/nonwritable-nonconfigurable-descriptors-basic.js b/js/src/tests/test262/language/arguments-object/mapped/nonwritable-nonconfigurable-descriptors-basic.js new file mode 100644 index 0000000000..fc049f9d55 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/nonwritable-nonconfigurable-descriptors-basic.js @@ -0,0 +1,42 @@ +// Copyright (C) 2017 Caio Lima. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Mapped arguments property descriptor change to non-writable and non-configurable +info: | + Mapping stop working when property is set to non-writable. Here we change the + descriptor using [[DefineOwnProperty]] to {writable: false} and then + change property descriptor to {configurable: false} in sequence. + The property descriptor need to be the one set before the property be + configured as {writable: false}. +flags: [noStrict] +esid: sec-arguments-exotic-objects-defineownproperty-p-desc +includes: [propertyHelper.js] +---*/ + +function fn(a) { + Object.defineProperty(arguments, "0", {writable: false}); + Object.defineProperty(arguments, "0", {configurable: false}); + + verifyProperty(arguments, "0", { + value: 1, + writable: false, + enumerable: true, + configurable: false, + }); + + // Postcondition: Arguments mapping is removed. Descriptors need to be the same + // as above. + a = 2; + + verifyProperty(arguments, "0", { + value: 1, + writable: false, + enumerable: true, + configurable: false, + }); +} +fn(1); + + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/nonwritable-nonconfigurable-descriptors-set-by-arguments.js b/js/src/tests/test262/language/arguments-object/mapped/nonwritable-nonconfigurable-descriptors-set-by-arguments.js new file mode 100644 index 0000000000..dd617821ff --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/nonwritable-nonconfigurable-descriptors-set-by-arguments.js @@ -0,0 +1,44 @@ +// Copyright (C) 2017 Caio Lima. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Mapped arguments property descriptor change to non-writable and non-configurable +info: | + Mapping stop working when property is set to non-writable. Change the + descriptor using [[DefineOwnProperty]] to {writable: false}, set argument[0] = 2 and then + change property descriptor to {configurable: false}. + The descriptor's value is the one set before the property be + configured as {writable: false} because mapping was removed. +flags: [noStrict] +esid: sec-arguments-exotic-objects-defineownproperty-p-desc +includes: [propertyHelper.js] +---*/ + +function fn(a) { + Object.defineProperty(arguments, "0", {writable: false}); + arguments[0] = 2; + Object.defineProperty(arguments, "0", {configurable: false}); + + assert.sameValue(a, 1); + + verifyProperty(arguments, "0", { + value: 1, + writable: false, + enumerable: true, + configurable: false, + }); + + // Postcondition: Arguments mapping is removed. + a = 3; + + verifyProperty(arguments, "0", { + value: 1, + writable: false, + enumerable: true, + configurable: false, + }); +} +fn(1); + + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/nonwritable-nonconfigurable-descriptors-set-by-param.js b/js/src/tests/test262/language/arguments-object/mapped/nonwritable-nonconfigurable-descriptors-set-by-param.js new file mode 100644 index 0000000000..5f676d3ea7 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/nonwritable-nonconfigurable-descriptors-set-by-param.js @@ -0,0 +1,32 @@ +// Copyright (C) 2017 Caio Lima. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Mapped arguments property descriptor change to non-writable and non-configurable +info: | + Mapping just stop working when property is set to non-writable. Change the + descriptor using [[DefineOwnProperty]] to {writable: false}, set a = 2 and then + change property descriptor to {configurable: false}. + The descriptor's value is the one set before the property be + configured as {writable: false} because mapping was removed. +flags: [noStrict] +esid: sec-arguments-exotic-objects-defineownproperty-p-desc +includes: [propertyHelper.js] +---*/ + +function fn(a) { + Object.defineProperty(arguments, "0", {writable: false}); + a = 2; + Object.defineProperty(arguments, "0", {configurable: false}); + + verifyProperty(arguments, "0", { + value: 1, + writable: false, + enumerable: true, + configurable: false, + }); +} +fn(1); + + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/nonwritable-nonenumerable-nonconfigurable-descriptors-basic.js b/js/src/tests/test262/language/arguments-object/mapped/nonwritable-nonenumerable-nonconfigurable-descriptors-basic.js new file mode 100644 index 0000000000..984f40c567 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/nonwritable-nonenumerable-nonconfigurable-descriptors-basic.js @@ -0,0 +1,40 @@ +// Copyright (C) 2017 Caio Lima. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Mapped arguments property descriptor change to non-writable and non-configurable +info: | + Change the descriptor using [[DefineOwnProperty]] to + {writable: false, enumerable: false} and then + change property descriptor to {configurable: false}. + The descriptor's enumerable property continue with its configured value + even if mapping stops. +flags: [noStrict] +esid: sec-arguments-exotic-objects-defineownproperty-p-desc +includes: [propertyHelper.js] +---*/ + +function fn(a) { + Object.defineProperty(arguments, "0", {writable: false, enumerable: false}); + Object.defineProperty(arguments, "0", {configurable: false}); + + verifyProperty(arguments, "0", { + value: 1, + writable: false, + enumerable: false, + configurable: false, + }); + + // Postcondition: Arguments mapping is removed. + a = 2; + + verifyProperty(arguments, "0", { + value: 1, + writable: false, + enumerable: false, + configurable: false, + }); +} +fn(1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/nonwritable-nonenumerable-nonconfigurable-descriptors-set-by-arguments.js b/js/src/tests/test262/language/arguments-object/mapped/nonwritable-nonenumerable-nonconfigurable-descriptors-set-by-arguments.js new file mode 100644 index 0000000000..ac1ba8fd3d --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/nonwritable-nonenumerable-nonconfigurable-descriptors-set-by-arguments.js @@ -0,0 +1,39 @@ +// Copyright (C) 2017 Caio Lima. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Mapped arguments property descriptor change to non-writable, non-enumerable and non-configurable +info: | + Change the descriptor using [[DefineOwnProperty]] to {writable: false, enumerable: false}, + set argument[0] = 2 and then change property descriptor to {configurable: false}. + The descriptor's enumerable property continues with its configured value. +flags: [noStrict] +esid: sec-arguments-exotic-objects-defineownproperty-p-desc +includes: [propertyHelper.js] +---*/ + +function fn(a) { + Object.defineProperty(arguments, "0", {writable: false, enumerable: false}); + arguments[0] = 2; + Object.defineProperty(arguments, "0", {configurable: false}); + + verifyProperty(arguments, "0", { + value: 1, + writable: false, + enumerable: false, + configurable: false, + }); + + // Postcondition: Arguments mapping is removed. + a = 3; + + verifyProperty(arguments, "0", { + value: 1, + writable: false, + enumerable: false, + configurable: false, + }); +} +fn(1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/nonwritable-nonenumerable-nonconfigurable-descriptors-set-by-define-property.js b/js/src/tests/test262/language/arguments-object/mapped/nonwritable-nonenumerable-nonconfigurable-descriptors-set-by-define-property.js new file mode 100644 index 0000000000..c1c3d798ea --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/nonwritable-nonenumerable-nonconfigurable-descriptors-set-by-define-property.js @@ -0,0 +1,29 @@ +// Copyright (C) 2017 Caio Lima. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Mapped arguments property descriptor change to non-writable, non-enumerable and non-configurable +info: | + Change the descriptor using [[DefineOwnProperty]] to + {writable: false, enumerable: false}, change argument[0] + value to 2 using [[DefineOwnProperty]] and then + change property descriptor to {configurable: false}. + The descriptor's enumerable property continues with its configured value. +flags: [noStrict] +esid: sec-arguments-exotic-objects-defineownproperty-p-desc +includes: [propertyHelper.js] +---*/ + +function fn(a) { + Object.defineProperty(arguments, "0", {writable: false, enumerable: false, value: 2, configurable: false}); + + verifyProperty(arguments, "0", { + value: 2, + writable: false, + enumerable: false, + configurable: false, + }); +} +fn(1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/nonwritable-nonenumerable-nonconfigurable-descriptors-set-by-param.js b/js/src/tests/test262/language/arguments-object/mapped/nonwritable-nonenumerable-nonconfigurable-descriptors-set-by-param.js new file mode 100644 index 0000000000..263f43f60c --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/nonwritable-nonenumerable-nonconfigurable-descriptors-set-by-param.js @@ -0,0 +1,40 @@ +// Copyright (C) 2017 Caio Lima. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: Mapped arguments property descriptor change to non-writable, non-enumerable and non-configurable +info: | + Change the descriptor using [[DefineOwnProperty]] to + {writable: false, enumerable: false}, set a = 2 and then + change property descriptor to {configurable: false}. + The descriptor's enumerable property continue with its configured value. +flags: [noStrict] +esid: sec-arguments-exotic-objects-defineownproperty-p-desc +includes: [propertyHelper.js] +---*/ + +function fn(a) { + Object.defineProperty(arguments, "0", {writable: false, enumerable: false}); + a = 2; + Object.defineProperty(arguments, "0", {configurable: false}); + + verifyProperty(arguments, "0", { + value: 1, + writable: false, + enumerable: false, + configurable: false, + }); + + // Postcondition: Arguments mapping is removed. + a = 3; + + verifyProperty(arguments, "0", { + value: 1, + writable: false, + enumerable: false, + configurable: false, + }); +} +fn(1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/mapped/shell.js b/js/src/tests/test262/language/arguments-object/mapped/shell.js new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/shell.js diff --git a/js/src/tests/test262/language/arguments-object/mapped/writable-enumerable-configurable-descriptor.js b/js/src/tests/test262/language/arguments-object/mapped/writable-enumerable-configurable-descriptor.js new file mode 100644 index 0000000000..01e9f2fb2f --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/mapped/writable-enumerable-configurable-descriptor.js @@ -0,0 +1,47 @@ +// Copyright (C) 2020 Alexey Shvayka. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-arguments-exotic-objects-defineownproperty-p-desc +description: > + Index stays mapped when redefined with complete descriptor, which differs only + by the [[Value]] field. Unmapped index is created. +info: | + [[DefineOwnProperty]] ( P, Desc ) + + [...] + 6. Let allowed be ? OrdinaryDefineOwnProperty(args, P, newArgDesc). + 7. If allowed is false, return false. + 8. If isMapped is true, then + [...] + b. Else, + i. If Desc.[[Value]] is present, then + 1. Let setStatus be Set(map, P, Desc.[[Value]], false). + 2. Assert: setStatus is true because formal parameters mapped by argument objects are always writable. + 9. Return true. +flags: [noStrict] +---*/ + +(function(a) { + Object.defineProperty(arguments, "0", { + value: "foo", + writable: true, + enumerable: true, + configurable: true, + }); + + assert.sameValue(a, "foo"); + assert.sameValue(arguments[0], "foo"); + + + Object.defineProperty(arguments, "1", { + value: "bar", + writable: true, + enumerable: true, + configurable: true, + }); + + assert.sameValue(arguments[1], "bar"); +})(0); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/meth-args-trailing-comma-multiple.js b/js/src/tests/test262/language/arguments-object/meth-args-trailing-comma-multiple.js new file mode 100644 index 0000000000..a789a8b229 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/meth-args-trailing-comma-multiple.js @@ -0,0 +1,49 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-multiple.case +// - src/arguments/default/meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using multiple args (method) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var obj = { + method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 'TC39'); + callCount = callCount + 1; + } +}; + +obj.method(42, 'TC39',); + +// Stores a reference `ref` for case evaluation +var ref = obj.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/meth-args-trailing-comma-null.js b/js/src/tests/test262/language/arguments-object/meth-args-trailing-comma-null.js new file mode 100644 index 0000000000..f59faa7e97 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/meth-args-trailing-comma-null.js @@ -0,0 +1,49 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-null.case +// - src/arguments/default/meth.template +/*--- +description: A trailing comma after null should not increase the arguments.length (method) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var obj = { + method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], null); + callCount = callCount + 1; + } +}; + +obj.method(42, null,); + +// Stores a reference `ref` for case evaluation +var ref = obj.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/meth-args-trailing-comma-single-args.js b/js/src/tests/test262/language/arguments-object/meth-args-trailing-comma-single-args.js new file mode 100644 index 0000000000..69965a5fbb --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/meth-args-trailing-comma-single-args.js @@ -0,0 +1,48 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-single-args.case +// - src/arguments/default/meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using a single arg (method) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var obj = { + method() { + assert.sameValue(arguments.length, 1); + assert.sameValue(arguments[0], 42); + callCount = callCount + 1; + } +}; + +obj.method(42,); + +// Stores a reference `ref` for case evaluation +var ref = obj.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/meth-args-trailing-comma-spread-operator.js b/js/src/tests/test262/language/arguments-object/meth-args-trailing-comma-spread-operator.js new file mode 100644 index 0000000000..da57776710 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/meth-args-trailing-comma-spread-operator.js @@ -0,0 +1,53 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-spread-operator.case +// - src/arguments/default/meth.template +/*--- +description: A trailing comma should not increase the arguments.length, using spread args (method) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ +var arr = [2, 3]; + + + +var callCount = 0; +var obj = { + method() { + assert.sameValue(arguments.length, 4); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], 1); + assert.sameValue(arguments[2], 2); + assert.sameValue(arguments[3], 3); + callCount = callCount + 1; + } +}; + +obj.method(42, ...[1], ...arr,); + +// Stores a reference `ref` for case evaluation +var ref = obj.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/meth-args-trailing-comma-undefined.js b/js/src/tests/test262/language/arguments-object/meth-args-trailing-comma-undefined.js new file mode 100644 index 0000000000..8651a63b30 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/meth-args-trailing-comma-undefined.js @@ -0,0 +1,49 @@ +// This file was procedurally generated from the following sources: +// - src/arguments/args-trailing-comma-undefined.case +// - src/arguments/default/meth.template +/*--- +description: A trailing comma after undefined should not increase the arguments.length (method) +esid: sec-arguments-exotic-objects +flags: [generated] +info: | + 9.4.4 Arguments Exotic Objects + + Most ECMAScript functions make an arguments object available to their code. Depending upon the + characteristics of the function definition, its arguments object is either an ordinary object + or an arguments exotic object. + + Trailing comma in the arguments list + + Left-Hand-Side Expressions + + Arguments : + ( ) + ( ArgumentList ) + ( ArgumentList , ) + + ArgumentList : + AssignmentExpression + ... AssignmentExpression + ArgumentList , AssignmentExpression + ArgumentList , ... AssignmentExpression +---*/ + + +var callCount = 0; +var obj = { + method() { + assert.sameValue(arguments.length, 2); + assert.sameValue(arguments[0], 42); + assert.sameValue(arguments[1], undefined); + callCount = callCount + 1; + } +}; + +obj.method(42, undefined,); + +// Stores a reference `ref` for case evaluation +var ref = obj.method; + +assert.sameValue(callCount, 1, 'method invoked exactly once'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/non-strict-arguments-object-is-immutable.js b/js/src/tests/test262/language/arguments-object/non-strict-arguments-object-is-immutable.js new file mode 100644 index 0000000000..3717a107f2 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/non-strict-arguments-object-is-immutable.js @@ -0,0 +1,23 @@ +// Copyright 2017 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-functiondeclarationinstantiation +description: Non-strict mode function execution context has a mutable "arguments" binding, however it is created with a "false" argument, which means it may not be deleted. +info: | + envRec.CreateMutableBinding("arguments", false). + + CreateMutableBinding(N, D) + + Create a new but uninitialized mutable binding in an Environment Record. The String value N is the text of the bound name. If the Boolean argument D is true the binding may be subsequently deleted. + +flags: [noStrict] +---*/ + +function f1() { + assert.sameValue(delete arguments, false); +} + +f1(); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/shell.js b/js/src/tests/test262/language/arguments-object/shell.js new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/shell.js diff --git a/js/src/tests/test262/language/arguments-object/unmapped/Symbol.iterator.js b/js/src/tests/test262/language/arguments-object/unmapped/Symbol.iterator.js new file mode 100644 index 0000000000..ea80626085 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/unmapped/Symbol.iterator.js @@ -0,0 +1,24 @@ +// Copyright (C) 2014 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +es6id: 9.4.4.6 S7 +description: > + Unmapped arguments exotic objects should implement the Array iterator + protocol. +includes: [propertyHelper.js] +flags: [noStrict] +features: [Symbol.iterator] +---*/ + +(function() { + 'use strict'; + + verifyProperty(arguments, Symbol.iterator, { + value: [][Symbol.iterator], + writable: true, + enumerable: false, + configurable: true, + }); +}()); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/unmapped/browser.js b/js/src/tests/test262/language/arguments-object/unmapped/browser.js new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/unmapped/browser.js diff --git a/js/src/tests/test262/language/arguments-object/unmapped/shell.js b/js/src/tests/test262/language/arguments-object/unmapped/shell.js new file mode 100644 index 0000000000..e69de29bb2 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/unmapped/shell.js diff --git a/js/src/tests/test262/language/arguments-object/unmapped/via-params-dflt.js b/js/src/tests/test262/language/arguments-object/unmapped/via-params-dflt.js new file mode 100644 index 0000000000..db16833e2d --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/unmapped/via-params-dflt.js @@ -0,0 +1,30 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-functiondeclarationinstantiation +es6id: 9.2.12 +description: > + Arguments are "unmapped" when paramater list is non-simple due to "default" + parameter +info: | + [...] + 9. Let simpleParameterList be IsSimpleParameterList of formals. + [...] + 22. If argumentsObjectNeeded is true, then + a. If strict is true or if simpleParameterList is false, then + i. Let ao be CreateUnmappedArgumentsObject(argumentsList). + [...] +---*/ + +var value; + +function dflt(a, b = 0) { + arguments[0] = 2; + value = a; +} + +dflt(1); + +assert.sameValue(value, 1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/unmapped/via-params-dstr.js b/js/src/tests/test262/language/arguments-object/unmapped/via-params-dstr.js new file mode 100644 index 0000000000..8d0a4e8d95 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/unmapped/via-params-dstr.js @@ -0,0 +1,30 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-functiondeclarationinstantiation +es6id: 9.2.12 +description: > + Arguments are "unmapped" when paramater list is non-simple due to + destructuring pattern +info: | + [...] + 9. Let simpleParameterList be IsSimpleParameterList of formals. + [...] + 22. If argumentsObjectNeeded is true, then + a. If strict is true or if simpleParameterList is false, then + i. Let ao be CreateUnmappedArgumentsObject(argumentsList). + [...] +---*/ + +var value; + +function dstr(a, [b]) { + arguments[0] = 2; + value = a; +} + +dstr(1, []); + +assert.sameValue(value, 1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/unmapped/via-params-rest.js b/js/src/tests/test262/language/arguments-object/unmapped/via-params-rest.js new file mode 100644 index 0000000000..8c4dab8dcd --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/unmapped/via-params-rest.js @@ -0,0 +1,30 @@ +// Copyright (C) 2016 the V8 project authors. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +esid: sec-functiondeclarationinstantiation +es6id: 9.2.12 +description: > + Arguments are "unmapped" when paramater list is non-simple due to "rest" + parameter +info: | + [...] + 9. Let simpleParameterList be IsSimpleParameterList of formals. + [...] + 22. If argumentsObjectNeeded is true, then + a. If strict is true or if simpleParameterList is false, then + i. Let ao be CreateUnmappedArgumentsObject(argumentsList). + [...] +---*/ + +var value; + +function rest(a, ...b) { + arguments[0] = 2; + value = a; +} + +rest(1); + +assert.sameValue(value, 1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/language/arguments-object/unmapped/via-strict-strict.js b/js/src/tests/test262/language/arguments-object/unmapped/via-strict-strict.js new file mode 100644 index 0000000000..620a0e9758 --- /dev/null +++ b/js/src/tests/test262/language/arguments-object/unmapped/via-strict-strict.js @@ -0,0 +1,19 @@ +'use strict'; +// Copyright (c) 2012 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +es5id: 10.6-10-c-ii-2-s +description: arguments[i] doesn't map to actual parameters in strict mode +flags: [onlyStrict] +---*/ + + function foo(a,b,c) + { + arguments[0] = 1; arguments[1] = 'str'; arguments[2] = 2.1; + return 10 === a && 'sss' === b && 1 === c; + } + +assert(foo(10,'sss',1), 'foo(10,"sss",1) !== true'); + +reportCompare(0, 0); |