Generate tests

test/language/eval-code/direct/arrow-fn-a-following-parameter-is-named-arguments-arrow-func-declare-arguments-assign-incl-def-param-arrow-arguments.js

@@ -0,0 +1,15 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/arrow-func-declare-arguments-assign-incl-def-param-arrow-arguments.case
+// - src/direct-eval-code/arrow-func/a-following-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a following parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+const f = (p = eval("var arguments = 'param'"), q = () => arguments, arguments) => {}
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/arrow-fn-a-following-parameter-is-named-arguments-arrow-func-declare-arguments-assign.js

@@ -0,0 +1,15 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/arrow-func-declare-arguments-assign.case
+// - src/direct-eval-code/arrow-func/a-following-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a following parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+const f = (p = eval("var arguments = 'param'"), arguments) => {}
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/arrow-fn-a-preceding-parameter-is-named-arguments-arrow-func-declare-arguments-assign-incl-def-param-arrow-arguments.js

@@ -0,0 +1,15 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/arrow-func-declare-arguments-assign-incl-def-param-arrow-arguments.case
+// - src/direct-eval-code/arrow-func/a-preceding-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a preceding parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+const f = (arguments, p = eval("var arguments = 'param'"), q = () => arguments) => {}
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/arrow-fn-a-preceding-parameter-is-named-arguments-arrow-func-declare-arguments-assign.js

@@ -0,0 +1,15 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/arrow-func-declare-arguments-assign.case
+// - src/direct-eval-code/arrow-func/a-preceding-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a preceding parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+const f = (arguments, p = eval("var arguments = 'param'")) => {}
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/arrow-fn-body-cntns-arguments-fn-decl-params-cntns-dflt-assignment-arrow-func-declare-arguments-assign-incl-def-param-arrow-arguments.js

@@ -0,0 +1,22 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/arrow-func-declare-arguments-assign-incl-def-param-arrow-arguments.case
+// - src/direct-eval-code/arrow-func/fn-body-cntns-arguments-fn-decl-params-cntns-dflt-assignment.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| function declaration.)
+esid: sec-evaldeclarationinstantiation
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+let count = 0;
+const f = (p = eval("var arguments = 'param'"), q = () => arguments) => {
+  function arguments() {}
+  assert.sameValue(typeof arguments, "function");
+  assert.sameValue(q(), "param");
+  count++;
+}
+f();
+assert.sameValue(count, 1);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/arrow-fn-body-cntns-arguments-fn-decl-params-cntns-dflt-assignment-arrow-func-declare-arguments-assign.js

@@ -0,0 +1,22 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/arrow-func-declare-arguments-assign.case
+// - src/direct-eval-code/arrow-func/fn-body-cntns-arguments-fn-decl-params-cntns-dflt-assignment.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| function declaration.)
+esid: sec-evaldeclarationinstantiation
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+let count = 0;
+const f = (p = eval("var arguments = 'param'")) => {
+  function arguments() {}
+  assert.sameValue(typeof arguments, "function");
+  
+  count++;
+}
+f();
+assert.sameValue(count, 1);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/arrow-fn-body-cntns-arguments-func-decl-arrow-func-declare-arguments-assign-incl-def-param-arrow-arguments.js

@@ -0,0 +1,22 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/arrow-func-declare-arguments-assign-incl-def-param-arrow-arguments.case
+// - src/direct-eval-code/arrow-func/fn-body-cntns-arguments-func-decl.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| function declaration.)
+esid: sec-evaldeclarationinstantiation
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+let count = 0;
+const f = (p = eval("var arguments = 'param'"), q = () => arguments) => {
+  function arguments() {}
+  assert.sameValue(typeof arguments, "function");
+  assert.sameValue(q(), "param");
+  count++;
+}
+f();
+assert.sameValue(count, 1);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/arrow-fn-body-cntns-arguments-func-decl-arrow-func-declare-arguments-assign.js

@@ -0,0 +1,22 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/arrow-func-declare-arguments-assign.case
+// - src/direct-eval-code/arrow-func/fn-body-cntns-arguments-func-decl.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| function declaration.)
+esid: sec-evaldeclarationinstantiation
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+let count = 0;
+const f = (p = eval("var arguments = 'param'")) => {
+  function arguments() {}
+  assert.sameValue(typeof arguments, "function");
+  
+  count++;
+}
+f();
+assert.sameValue(count, 1);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/arrow-fn-body-cntns-arguments-lex-bind-arrow-func-declare-arguments-assign-incl-def-param-arrow-arguments.js

@@ -0,0 +1,22 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/arrow-func-declare-arguments-assign-incl-def-param-arrow-arguments.case
+// - src/direct-eval-code/arrow-func/fn-body-cntns-arguments-lex-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| lexical binding.)
+esid: sec-evaldeclarationinstantiation
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+let count = 0;
+const f = (p = eval("var arguments = 'param'"), q = () => arguments) => {
+  let arguments = "local";
+  assert.sameValue(arguments, "local");
+  assert.sameValue(q(), "param");
+  count++;
+}
+f();
+assert.sameValue(count, 1);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/arrow-fn-body-cntns-arguments-lex-bind-arrow-func-declare-arguments-assign.js

@@ -0,0 +1,22 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/arrow-func-declare-arguments-assign.case
+// - src/direct-eval-code/arrow-func/fn-body-cntns-arguments-lex-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| lexical binding.)
+esid: sec-evaldeclarationinstantiation
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+let count = 0;
+const f = (p = eval("var arguments = 'param'")) => {
+  let arguments = "local";
+  assert.sameValue(arguments, "local");
+  
+  count++;
+}
+f();
+assert.sameValue(count, 1);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/arrow-fn-body-cntns-arguments-var-bind-arrow-func-declare-arguments-assign-incl-def-param-arrow-arguments.js

@@ -0,0 +1,22 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/arrow-func-declare-arguments-assign-incl-def-param-arrow-arguments.case
+// - src/direct-eval-code/arrow-func/fn-body-cntns-arguments-var-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| var-binding.)
+esid: sec-evaldeclarationinstantiation
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+let count = 0;
+const f = (p = eval("var arguments = 'param'"), q = () => arguments) => {
+  var arguments = "local";
+  assert.sameValue(arguments, "local");
+  assert.sameValue(q(), "param");
+  count++;
+}
+f();
+assert.sameValue(count, 1);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/arrow-fn-body-cntns-arguments-var-bind-arrow-func-declare-arguments-assign.js

@@ -0,0 +1,22 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/arrow-func-declare-arguments-assign.case
+// - src/direct-eval-code/arrow-func/fn-body-cntns-arguments-var-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| var-binding.)
+esid: sec-evaldeclarationinstantiation
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+let count = 0;
+const f = (p = eval("var arguments = 'param'")) => {
+  var arguments = "local";
+  assert.sameValue(arguments, "local");
+  
+  count++;
+}
+f();
+assert.sameValue(count, 1);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/arrow-fn-no-pre-existing-arguments-bindings-are-present-arrow-func-declare-arguments-assign-incl-def-param-arrow-arguments.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/arrow-func-declare-arguments-assign-incl-def-param-arrow-arguments.case
+// - src/direct-eval-code/arrow-func/no-pre-existing-arguments-bindings-are-present.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when no pre-existing |arguments| bindings are present.)
+esid: sec-evaldeclarationinstantiation
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+let count = 0;
+const f = (p = eval("var arguments = 'param'"), q = () => arguments) => {
+  assert.sameValue(arguments, "param");
+  count++;
+}
+f();
+assert.sameValue(count, 1);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/arrow-fn-no-pre-existing-arguments-bindings-are-present-arrow-func-declare-arguments-assign.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/arrow-func-declare-arguments-assign.case
+// - src/direct-eval-code/arrow-func/no-pre-existing-arguments-bindings-are-present.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when no pre-existing |arguments| bindings are present.)
+esid: sec-evaldeclarationinstantiation
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+let count = 0;
+const f = (p = eval("var arguments = 'param'")) => {
+  assert.sameValue(arguments, "param");
+  count++;
+}
+f();
+assert.sameValue(count, 1);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-func-decl-a-following-parameter-is-named-arguments-declare-arguments-and-assign.js

@@ -0,0 +1,22 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-func-decl/a-following-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a following parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+async function f(p = eval("var arguments = 'param'"), arguments) {
+  
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);
+

test/language/eval-code/direct/async-func-decl-a-following-parameter-is-named-arguments-declare-arguments.js

@@ -0,0 +1,22 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-func-decl/a-following-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a following parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+async function f(p = eval("var arguments"), arguments) {
+  
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);
+

test/language/eval-code/direct/async-func-decl-a-preceding-parameter-is-named-arguments-declare-arguments-and-assign.js

@@ -0,0 +1,22 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-func-decl/a-preceding-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a preceding parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+async function f(arguments, p = eval("var arguments = 'param'")) {
+  
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);
+

test/language/eval-code/direct/async-func-decl-a-preceding-parameter-is-named-arguments-declare-arguments.js

@@ -0,0 +1,22 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-func-decl/a-preceding-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a preceding parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+async function f(arguments, p = eval("var arguments")) {
+  
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);
+

test/language/eval-code/direct/async-func-decl-fn-body-cntns-arguments-func-decl-declare-arguments-and-assign.js

@@ -0,0 +1,21 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-func-decl/fn-body-cntns-arguments-func-decl.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| function declaration.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+async function f(p = eval("var arguments = 'param'")) {
+  function arguments() {}
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

test/language/eval-code/direct/async-func-decl-fn-body-cntns-arguments-func-decl-declare-arguments.js

@@ -0,0 +1,21 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-func-decl/fn-body-cntns-arguments-func-decl.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| function declaration.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+async function f(p = eval("var arguments")) {
+  function arguments() {}
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

test/language/eval-code/direct/async-func-decl-fn-body-cntns-arguments-lex-bind-declare-arguments-and-assign.js

@@ -0,0 +1,21 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-func-decl/fn-body-cntns-arguments-lex-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| lexical binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+async function f(p = eval("var arguments = 'param'")) {
+  let arguments;
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

test/language/eval-code/direct/async-func-decl-fn-body-cntns-arguments-lex-bind-declare-arguments.js

@@ -0,0 +1,21 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-func-decl/fn-body-cntns-arguments-lex-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| lexical binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+async function f(p = eval("var arguments")) {
+  let arguments;
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

test/language/eval-code/direct/async-func-decl-fn-body-cntns-arguments-var-bind-declare-arguments-and-assign.js

@@ -0,0 +1,21 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-func-decl/fn-body-cntns-arguments-var-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| var-binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+async function f(p = eval("var arguments = 'param'")) {
+  var arguments;
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

test/language/eval-code/direct/async-func-decl-fn-body-cntns-arguments-var-bind-declare-arguments.js

@@ -0,0 +1,21 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-func-decl/fn-body-cntns-arguments-var-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| var-binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+async function f(p = eval("var arguments")) {
+  var arguments;
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

test/language/eval-code/direct/async-func-decl-no-pre-existing-arguments-bindings-are-present-declare-arguments-and-assign.js

@@ -0,0 +1,19 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-func-decl/no-pre-existing-arguments-bindings-are-present.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when no pre-existing |arguments| bindings are present.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+async function f(p = eval("var arguments = 'param'")) {}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

test/language/eval-code/direct/async-func-decl-no-pre-existing-arguments-bindings-are-present-declare-arguments.js

@@ -0,0 +1,19 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-func-decl/no-pre-existing-arguments-bindings-are-present.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when no pre-existing |arguments| bindings are present.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+async function f(p = eval("var arguments")) {}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

test/language/eval-code/direct/async-func-expr-named-a-following-parameter-is-named-arguments-declare-arguments-and-assign.js

@@ -0,0 +1,22 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-func-expr-named/a-following-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a following parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function f(p = eval("var arguments = 'param'"), arguments) {
+  
+};
+f().then($DONE, error => {
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+  assert(error instanceof SyntaxError);
+}).then($DONE, $DONE);
+

test/language/eval-code/direct/async-func-expr-named-a-following-parameter-is-named-arguments-declare-arguments.js

@@ -0,0 +1,22 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-func-expr-named/a-following-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a following parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function f(p = eval("var arguments"), arguments) {
+  
+};
+f().then($DONE, error => {
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+  assert(error instanceof SyntaxError);
+}).then($DONE, $DONE);
+

test/language/eval-code/direct/async-func-expr-named-a-preceding-parameter-is-named-arguments-declare-arguments-and-assign.js

@@ -0,0 +1,22 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-func-expr-named/a-preceding-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a preceding parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function f(arguments, p = eval("var arguments = 'param'")) {
+  
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);
+

test/language/eval-code/direct/async-func-expr-named-a-preceding-parameter-is-named-arguments-declare-arguments.js

@@ -0,0 +1,22 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-func-expr-named/a-preceding-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a preceding parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function f(arguments, p = eval("var arguments")) {
+  
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);
+

test/language/eval-code/direct/async-func-expr-named-fn-body-cntns-arguments-func-decl-declare-arguments-and-assign.js

@@ -0,0 +1,22 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-func-expr-named/fn-body-cntns-arguments-func-decl.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| function declaration.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function f(p = eval("var arguments = 'param'")) {
+  function arguments() {}
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);
+

test/language/eval-code/direct/async-func-expr-named-fn-body-cntns-arguments-func-decl-declare-arguments.js

@@ -0,0 +1,22 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-func-expr-named/fn-body-cntns-arguments-func-decl.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| function declaration.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function f(p = eval("var arguments")) {
+  function arguments() {}
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);
+

test/language/eval-code/direct/async-func-expr-named-fn-body-cntns-arguments-lex-bind-declare-arguments-and-assign.js

@@ -0,0 +1,22 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-func-expr-named/fn-body-cntns-arguments-lex-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| lexical binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function f(p = eval("var arguments = 'param'")) {
+  let arguments;
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);
+

test/language/eval-code/direct/async-func-expr-named-fn-body-cntns-arguments-lex-bind-declare-arguments.js

@@ -0,0 +1,22 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-func-expr-named/fn-body-cntns-arguments-lex-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| lexical binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function f(p = eval("var arguments")) {
+  let arguments;
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);
+

test/language/eval-code/direct/async-func-expr-named-fn-body-cntns-arguments-var-bind-declare-arguments-and-assign.js

@@ -0,0 +1,22 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-func-expr-named/fn-body-cntns-arguments-var-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| var-binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function f(p = eval("var arguments = 'param'")) {
+  var arguments;
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);
+

test/language/eval-code/direct/async-func-expr-named-fn-body-cntns-arguments-var-bind-declare-arguments.js

@@ -0,0 +1,22 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-func-expr-named/fn-body-cntns-arguments-var-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| var-binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function f(p = eval("var arguments")) {
+  var arguments;
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);
+

test/language/eval-code/direct/async-func-expr-named-no-pre-existing-arguments-bindings-are-present-declare-arguments-and-assign.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-func-expr-named/no-pre-existing-arguments-bindings-are-present.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when no pre-existing |arguments| bindings are present.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function f(p = eval("var arguments = 'param'")) {}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);
+

test/language/eval-code/direct/async-func-expr-named-no-pre-existing-arguments-bindings-are-present-declare-arguments.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-func-expr-named/no-pre-existing-arguments-bindings-are-present.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when no pre-existing |arguments| bindings are present.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function f(p = eval("var arguments")) {}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);
+

test/language/eval-code/direct/async-func-expr-nameless-a-following-parameter-is-named-arguments-declare-arguments-and-assign.js

@@ -0,0 +1,21 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-func-expr-nameless/a-following-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a following parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function(p = eval("var arguments = 'param'"), arguments) {
+  
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

test/language/eval-code/direct/async-func-expr-nameless-a-following-parameter-is-named-arguments-declare-arguments.js

@@ -0,0 +1,21 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-func-expr-nameless/a-following-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a following parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function(p = eval("var arguments"), arguments) {
+  
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

test/language/eval-code/direct/async-func-expr-nameless-a-preceding-parameter-is-named-arguments-declare-arguments-and-assign.js

@@ -0,0 +1,21 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-func-expr-nameless/a-preceding-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a preceding parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function(arguments, p = eval("var arguments = 'param'")) {
+  
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

test/language/eval-code/direct/async-func-expr-nameless-a-preceding-parameter-is-named-arguments-declare-arguments.js

@@ -0,0 +1,21 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-func-expr-nameless/a-preceding-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a preceding parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function(arguments, p = eval("var arguments")) {
+  
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

test/language/eval-code/direct/async-func-expr-nameless-fn-body-cntns-arguments-func-decl-declare-arguments-and-assign.js

@@ -0,0 +1,21 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-func-expr-nameless/fn-body-cntns-arguments-func-decl.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| function declaration.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function(p = eval("var arguments = 'param'")) {
+  function arguments() {}
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

test/language/eval-code/direct/async-func-expr-nameless-fn-body-cntns-arguments-func-decl-declare-arguments.js

@@ -0,0 +1,21 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-func-expr-nameless/fn-body-cntns-arguments-func-decl.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| function declaration.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function(p = eval("var arguments")) {
+  function arguments() {}
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

test/language/eval-code/direct/async-func-expr-nameless-fn-body-cntns-arguments-lex-bind-declare-arguments-and-assign.js

@@ -0,0 +1,21 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-func-expr-nameless/fn-body-cntns-arguments-lex-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| lexical binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function(p = eval("var arguments = 'param'")) {
+  let arguments;
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

test/language/eval-code/direct/async-func-expr-nameless-fn-body-cntns-arguments-lex-bind-declare-arguments.js

@@ -0,0 +1,21 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-func-expr-nameless/fn-body-cntns-arguments-lex-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| lexical binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function(p = eval("var arguments")) {
+  let arguments;
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

test/language/eval-code/direct/async-func-expr-nameless-fn-body-cntns-arguments-var-bind-declare-arguments-and-assign.js

@@ -0,0 +1,21 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-func-expr-nameless/fn-body-cntns-arguments-var-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| var-binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function(p = eval("var arguments = 'param'")) {
+  var arguments;
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

test/language/eval-code/direct/async-func-expr-nameless-fn-body-cntns-arguments-var-bind-declare-arguments.js

@@ -0,0 +1,21 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-func-expr-nameless/fn-body-cntns-arguments-var-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| var-binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function(p = eval("var arguments")) {
+  var arguments;
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

test/language/eval-code/direct/async-func-expr-nameless-no-pre-existing-arguments-bindings-are-present-declare-arguments-and-assign.js

@@ -0,0 +1,19 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-func-expr-nameless/no-pre-existing-arguments-bindings-are-present.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when no pre-existing |arguments| bindings are present.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function(p = eval("var arguments = 'param'")) {}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

test/language/eval-code/direct/async-func-expr-nameless-no-pre-existing-arguments-bindings-are-present-declare-arguments.js

@@ -0,0 +1,19 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-func-expr-nameless/no-pre-existing-arguments-bindings-are-present.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when no pre-existing |arguments| bindings are present.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function(p = eval("var arguments")) {}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

test/language/eval-code/direct/async-gen-func-decl-a-following-parameter-is-named-arguments-declare-arguments-and-assign.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-gen-func-decl/a-following-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a following parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+async function * f(p = eval("var arguments = 'param'"), arguments) {
+  
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-func-decl-a-following-parameter-is-named-arguments-declare-arguments.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-gen-func-decl/a-following-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a following parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+async function * f(p = eval("var arguments"), arguments) {
+  
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-func-decl-a-preceding-parameter-is-named-arguments-declare-arguments-and-assign.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-gen-func-decl/a-preceding-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a preceding parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+async function * f(arguments, p = eval("var arguments = 'param'")) {
+  
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-func-decl-a-preceding-parameter-is-named-arguments-declare-arguments.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-gen-func-decl/a-preceding-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a preceding parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+async function * f(arguments, p = eval("var arguments")) {
+  
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-func-decl-fn-body-cntns-arguments-func-decl-declare-arguments-and-assign.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-gen-func-decl/fn-body-cntns-arguments-func-decl.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| function declaration.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+async function * f(p = eval("var arguments = 'param'")) {
+  function arguments() {}
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-func-decl-fn-body-cntns-arguments-func-decl-declare-arguments.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-gen-func-decl/fn-body-cntns-arguments-func-decl.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| function declaration.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+async function * f(p = eval("var arguments")) {
+  function arguments() {}
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-func-decl-fn-body-cntns-arguments-lex-bind-declare-arguments-and-assign.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-gen-func-decl/fn-body-cntns-arguments-lex-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| lexical binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+async function * f(p = eval("var arguments = 'param'")) {
+  let arguments;
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-func-decl-fn-body-cntns-arguments-lex-bind-declare-arguments.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-gen-func-decl/fn-body-cntns-arguments-lex-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| lexical binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+async function * f(p = eval("var arguments")) {
+  let arguments;
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-func-decl-fn-body-cntns-arguments-var-bind-declare-arguments-and-assign.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-gen-func-decl/fn-body-cntns-arguments-var-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| var-binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+async function * f(p = eval("var arguments = 'param'")) {
+  var arguments;
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-func-decl-fn-body-cntns-arguments-var-bind-declare-arguments.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-gen-func-decl/fn-body-cntns-arguments-var-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| var-binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+async function * f(p = eval("var arguments")) {
+  var arguments;
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-func-decl-no-pre-existing-arguments-bindings-are-present-declare-arguments-and-assign.js

@@ -0,0 +1,18 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-gen-func-decl/no-pre-existing-arguments-bindings-are-present.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when no pre-existing |arguments| bindings are present.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+async function * f(p = eval("var arguments = 'param'")) {}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-func-decl-no-pre-existing-arguments-bindings-are-present-declare-arguments.js

@@ -0,0 +1,18 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-gen-func-decl/no-pre-existing-arguments-bindings-are-present.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when no pre-existing |arguments| bindings are present.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+async function * f(p = eval("var arguments")) {}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-func-expr-a-following-parameter-is-named-arguments-declare-arguments-and-assign.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-gen-func-expr/a-following-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a following parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * (p = eval("var arguments = 'param'"), arguments) {
+  
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-func-expr-a-following-parameter-is-named-arguments-declare-arguments.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-gen-func-expr/a-following-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a following parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * (p = eval("var arguments"), arguments) {
+  
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-func-expr-a-preceding-parameter-is-named-arguments-declare-arguments-and-assign.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-gen-func-expr/a-preceding-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a preceding parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * (arguments, p = eval("var arguments = 'param'")) {
+  
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-func-expr-a-preceding-parameter-is-named-arguments-declare-arguments.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-gen-func-expr/a-preceding-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a preceding parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * (arguments, p = eval("var arguments")) {
+  
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-func-expr-fn-body-cntns-arguments-func-decl-declare-arguments-and-assign.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-gen-func-expr/fn-body-cntns-arguments-func-decl.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| function declaration.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * (p = eval("var arguments = 'param'")) {
+  function arguments() {}
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-func-expr-fn-body-cntns-arguments-func-decl-declare-arguments.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-gen-func-expr/fn-body-cntns-arguments-func-decl.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| function declaration.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * (p = eval("var arguments")) {
+  function arguments() {}
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-func-expr-fn-body-cntns-arguments-lex-bind-declare-arguments-and-assign.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-gen-func-expr/fn-body-cntns-arguments-lex-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| lexical binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * (p = eval("var arguments = 'param'")) {
+  let arguments;
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-func-expr-fn-body-cntns-arguments-lex-bind-declare-arguments.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-gen-func-expr/fn-body-cntns-arguments-lex-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| lexical binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * (p = eval("var arguments")) {
+  let arguments;
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-func-expr-fn-body-cntns-arguments-var-bind-declare-arguments-and-assign.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-gen-func-expr/fn-body-cntns-arguments-var-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| var-binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * (p = eval("var arguments = 'param'")) {
+  var arguments;
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-func-expr-fn-body-cntns-arguments-var-bind-declare-arguments.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-gen-func-expr/fn-body-cntns-arguments-var-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| var-binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * (p = eval("var arguments")) {
+  var arguments;
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-func-expr-no-pre-existing-arguments-bindings-are-present-declare-arguments-and-assign.js

@@ -0,0 +1,18 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-gen-func-expr/no-pre-existing-arguments-bindings-are-present.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when no pre-existing |arguments| bindings are present.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * (p = eval("var arguments = 'param'")) {}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-func-expr-no-pre-existing-arguments-bindings-are-present-declare-arguments.js

@@ -0,0 +1,18 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-gen-func-expr/no-pre-existing-arguments-bindings-are-present.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when no pre-existing |arguments| bindings are present.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * (p = eval("var arguments")) {}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-meth-a-following-parameter-is-named-arguments-declare-arguments-and-assign.js

@@ -0,0 +1,19 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-gen-meth/a-following-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a following parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let o = { async *f(p = eval("var arguments = 'param'"), arguments) {
+  
+}};
+assert.throws(SyntaxError, o.f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-meth-a-following-parameter-is-named-arguments-declare-arguments.js

@@ -0,0 +1,19 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-gen-meth/a-following-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a following parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let o = { async *f(p = eval("var arguments"), arguments) {
+  
+}};
+assert.throws(SyntaxError, o.f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-meth-a-preceding-parameter-is-named-arguments-declare-arguments-and-assign.js

@@ -0,0 +1,19 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-gen-meth/a-preceding-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a preceding parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let o = { async *f(arguments, p = eval("var arguments = 'param'")) {
+  
+}};
+assert.throws(SyntaxError, o.f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-meth-a-preceding-parameter-is-named-arguments-declare-arguments.js

@@ -0,0 +1,19 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-gen-meth/a-preceding-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a preceding parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let o = { async *f(arguments, p = eval("var arguments")) {
+  
+}};
+assert.throws(SyntaxError, o.f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-meth-fn-body-cntns-arguments-func-decl-declare-arguments-and-assign.js

@@ -0,0 +1,19 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-gen-meth/fn-body-cntns-arguments-func-decl.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| function declaration.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let o = { async *f(p = eval("var arguments = 'param'")) {
+  function arguments() {}
+}};
+assert.throws(SyntaxError, o.f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-meth-fn-body-cntns-arguments-func-decl-declare-arguments.js

@@ -0,0 +1,19 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-gen-meth/fn-body-cntns-arguments-func-decl.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| function declaration.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let o = { async *f(p = eval("var arguments")) {
+  function arguments() {}
+}};
+assert.throws(SyntaxError, o.f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-meth-fn-body-cntns-arguments-lex-bind-declare-arguments-and-assign.js

@@ -0,0 +1,19 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-gen-meth/fn-body-cntns-arguments-lex-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| lexical binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let o = { async *f(p = eval("var arguments = 'param'")) {
+  let arguments;
+}};
+assert.throws(SyntaxError, o.f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-meth-fn-body-cntns-arguments-lex-bind-declare-arguments.js

@@ -0,0 +1,19 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-gen-meth/fn-body-cntns-arguments-lex-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| lexical binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let o = { async *f(p = eval("var arguments")) {
+  let arguments;
+}};
+assert.throws(SyntaxError, o.f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-meth-fn-body-cntns-arguments-var-bind-declare-arguments-and-assign.js

@@ -0,0 +1,19 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-gen-meth/fn-body-cntns-arguments-var-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| var-binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let o = { async *f(p = eval("var arguments = 'param'")) {
+  var arguments;
+}};
+assert.throws(SyntaxError, o.f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-meth-fn-body-cntns-arguments-var-bind-declare-arguments.js

@@ -0,0 +1,19 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-gen-meth/fn-body-cntns-arguments-var-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| var-binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let o = { async *f(p = eval("var arguments")) {
+  var arguments;
+}};
+assert.throws(SyntaxError, o.f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-meth-no-pre-existing-arguments-bindings-are-present-declare-arguments-and-assign.js

@@ -0,0 +1,17 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-gen-meth/no-pre-existing-arguments-bindings-are-present.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when no pre-existing |arguments| bindings are present.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let o = { async *f(p = eval("var arguments = 'param'")) {}};
+assert.throws(SyntaxError, o.f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-meth-no-pre-existing-arguments-bindings-are-present-declare-arguments.js

@@ -0,0 +1,17 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-gen-meth/no-pre-existing-arguments-bindings-are-present.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when no pre-existing |arguments| bindings are present.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let o = { async *f(p = eval("var arguments")) {}};
+assert.throws(SyntaxError, o.f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-named-func-expr-a-following-parameter-is-named-arguments-declare-arguments-and-assign.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-gen-named-func-expr/a-following-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a following parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * f(p = eval("var arguments = 'param'"), arguments) {
+  
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-named-func-expr-a-following-parameter-is-named-arguments-declare-arguments.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-gen-named-func-expr/a-following-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a following parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * f(p = eval("var arguments"), arguments) {
+  
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-named-func-expr-a-preceding-parameter-is-named-arguments-declare-arguments-and-assign.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-gen-named-func-expr/a-preceding-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a preceding parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * f(arguments, p = eval("var arguments = 'param'")) {
+  
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-named-func-expr-a-preceding-parameter-is-named-arguments-declare-arguments.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-gen-named-func-expr/a-preceding-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a preceding parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * f(arguments, p = eval("var arguments")) {
+  
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-named-func-expr-fn-body-cntns-arguments-func-decl-declare-arguments-and-assign.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-gen-named-func-expr/fn-body-cntns-arguments-func-decl.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| function declaration.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * f(p = eval("var arguments = 'param'")) {
+  function arguments() {}
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-named-func-expr-fn-body-cntns-arguments-func-decl-declare-arguments.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-gen-named-func-expr/fn-body-cntns-arguments-func-decl.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| function declaration.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * f(p = eval("var arguments")) {
+  function arguments() {}
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-named-func-expr-fn-body-cntns-arguments-lex-bind-declare-arguments-and-assign.js

@@ -0,0 +1,21 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-gen-named-func-expr/fn-body-cntns-arguments-lex-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| lexical binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * f(p = eval("var arguments = 'param'")) {
+  let arguments;
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+

test/language/eval-code/direct/async-gen-named-func-expr-fn-body-cntns-arguments-lex-bind-declare-arguments.js

@@ -0,0 +1,21 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-gen-named-func-expr/fn-body-cntns-arguments-lex-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| lexical binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * f(p = eval("var arguments")) {
+  let arguments;
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+

test/language/eval-code/direct/async-gen-named-func-expr-fn-body-cntns-arguments-var-bind-declare-arguments-and-assign.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-gen-named-func-expr/fn-body-cntns-arguments-var-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| var-binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * f(p = eval("var arguments = 'param'")) {
+  var arguments;
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-named-func-expr-fn-body-cntns-arguments-var-bind-declare-arguments.js

@@ -0,0 +1,20 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-gen-named-func-expr/fn-body-cntns-arguments-var-bind.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when the function body contains an |arguments| var-binding.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * f(p = eval("var arguments")) {
+  var arguments;
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-named-func-expr-no-pre-existing-arguments-bindings-are-present-declare-arguments-and-assign.js

@@ -0,0 +1,18 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-gen-named-func-expr/no-pre-existing-arguments-bindings-are-present.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when no pre-existing |arguments| bindings are present.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * f(p = eval("var arguments = 'param'")) {}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-gen-named-func-expr-no-pre-existing-arguments-bindings-are-present-declare-arguments.js

@@ -0,0 +1,18 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-gen-named-func-expr/no-pre-existing-arguments-bindings-are-present.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when no pre-existing |arguments| bindings are present.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * f(p = eval("var arguments")) {}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

test/language/eval-code/direct/async-meth-a-following-parameter-is-named-arguments-declare-arguments-and-assign.js

@@ -0,0 +1,21 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments-and-assign.case
+// - src/direct-eval-code/default/async-meth/a-following-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a following parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let o = { async f(p = eval("var arguments = 'param'"), arguments) {
+  
+}};
+o.f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

test/language/eval-code/direct/async-meth-a-following-parameter-is-named-arguments-declare-arguments.js

@@ -0,0 +1,21 @@
+// This file was procedurally generated from the following sources:
+// - src/direct-eval-code/declare-arguments.case
+// - src/direct-eval-code/default/async-meth/a-following-parameter-is-named-arguments.template
+/*---
+description: Declare "arguments" and assign to it in direct eval code (Declare |arguments| when a following parameter is named |arguments|.)
+esid: sec-evaldeclarationinstantiation
+features: [globalThis]
+flags: [generated, async, noStrict]
+---*/
+
+
+const oldArguments = globalThis.arguments;
+
+
+let o = { async f(p = eval("var arguments"), arguments) {
+  
+}};
+o.f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);