Redeclaration of argument in direct eval in parameter expressions

src/direct-eval-code/arrow-func-declare-arguments-assign-incl-def-param-arrow-arguments.case

@@ -0,0 +1,11 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: Declare "arguments" and assign to it in direct eval code
+template: arrow-func
+---*/
+
+//- parameter-code
+eval("var arguments = 'param'"), q = () => arguments
+//- body
+assert.sameValue(q(), "param");

src/direct-eval-code/arrow-func-declare-arguments-assign.case

@@ -0,0 +1,9 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: Declare "arguments" and assign to it in direct eval code
+template: arrow-func
+---*/
+
+//- parameter-code
+eval("var arguments = 'param'")

src/direct-eval-code/arrow-func/a-following-parameter-is-named-arguments.template

@@ -0,0 +1,15 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/arrow-fn-a-following-parameter-is-named-arguments-
+name: Declare |arguments| when a following parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+const f = (p = /*{ parameter-code }*/, arguments) => {}
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/arrow-func/a-preceding-parameter-is-named-arguments.template

@@ -0,0 +1,15 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/arrow-fn-a-preceding-parameter-is-named-arguments-
+name: Declare |arguments| when a preceding parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+const f = (arguments, p = /*{ parameter-code }*/) => {}
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/arrow-func/fn-body-cntns-arguments-fn-decl-params-cntns-dflt-assignment.template

@@ -0,0 +1,22 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/arrow-fn-body-cntns-arguments-fn-decl-params-cntns-dflt-assignment-
+name: Declare |arguments| when the function body contains an |arguments| function declaration.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+let count = 0;
+const f = (p = /*{ parameter-code }*/) => {
+  function arguments() {}
+  assert.sameValue(typeof arguments, "function");
+  /*{ body }*/
+  count++;
+}
+f();
+assert.sameValue(count, 1);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/arrow-func/fn-body-cntns-arguments-func-decl.template

@@ -0,0 +1,22 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/arrow-fn-body-cntns-arguments-func-decl-
+name: Declare |arguments| when the function body contains an |arguments| function declaration.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+let count = 0;
+const f = (p = /*{ parameter-code }*/) => {
+  function arguments() {}
+  assert.sameValue(typeof arguments, "function");
+  /*{ body }*/
+  count++;
+}
+f();
+assert.sameValue(count, 1);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/arrow-func/fn-body-cntns-arguments-lex-bind.template

@@ -0,0 +1,22 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/arrow-fn-body-cntns-arguments-lex-bind-
+name: Declare |arguments| when the function body contains an |arguments| lexical binding.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+let count = 0;
+const f = (p = /*{ parameter-code }*/) => {
+  let arguments = "local";
+  assert.sameValue(arguments, "local");
+  /*{ body }*/
+  count++;
+}
+f();
+assert.sameValue(count, 1);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/arrow-func/fn-body-cntns-arguments-var-bind.template

@@ -0,0 +1,22 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/arrow-fn-body-cntns-arguments-var-bind-
+name: Declare |arguments| when the function body contains an |arguments| var-binding.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+let count = 0;
+const f = (p = /*{ parameter-code }*/) => {
+  var arguments = "local";
+  assert.sameValue(arguments, "local");
+  /*{ body }*/
+  count++;
+}
+f();
+assert.sameValue(count, 1);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/arrow-func/no-pre-existing-arguments-bindings-are-present.template

@@ -0,0 +1,20 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/arrow-fn-no-pre-existing-arguments-bindings-are-present-
+name: Declare |arguments| when no pre-existing |arguments| bindings are present.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+let count = 0;
+const f = (p = /*{ parameter-code }*/) => {
+  assert.sameValue(arguments, "param");
+  count++;
+}
+f();
+assert.sameValue(count, 1);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/declare-arguments-and-assign.case

@@ -0,0 +1,9 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: Declare "arguments" and assign to it in direct eval code
+template: default/*
+---*/
+
+//- parameter-code
+eval("var arguments = 'param'")

src/direct-eval-code/declare-arguments.case

@@ -0,0 +1,9 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+desc: Declare "arguments" and assign to it in direct eval code
+template: default/*
+---*/
+
+//- parameter-code
+eval("var arguments")

src/direct-eval-code/default/async-func-decl/a-following-parameter-is-named-arguments.template

@@ -0,0 +1,22 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-func-decl-a-following-parameter-is-named-arguments-
+name: Declare |arguments| when a following parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [async,noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+async function f(p = /*{ parameter-code }*/, arguments) {
+  /*{ body }*/
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);
+

src/direct-eval-code/default/async-func-decl/a-preceding-parameter-is-named-arguments.template

@@ -0,0 +1,22 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-func-decl-a-preceding-parameter-is-named-arguments-
+name: Declare |arguments| when a preceding parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [async,noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+async function f(arguments, p = /*{ parameter-code }*/) {
+  /*{ body }*/
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);
+

src/direct-eval-code/default/async-func-decl/fn-body-cntns-arguments-func-decl.template

@@ -0,0 +1,21 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-func-decl-fn-body-cntns-arguments-func-decl-
+name: Declare |arguments| when the function body contains an |arguments| function declaration.
+esid: sec-evaldeclarationinstantiation
+flags: [async,noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+async function f(p = /*{ parameter-code }*/) {
+  function arguments() {}
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

src/direct-eval-code/default/async-func-decl/fn-body-cntns-arguments-lex-bind.template

@@ -0,0 +1,21 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-func-decl-fn-body-cntns-arguments-lex-bind-
+name: Declare |arguments| when the function body contains an |arguments| lexical binding.
+esid: sec-evaldeclarationinstantiation
+flags: [async,noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+async function f(p = /*{ parameter-code }*/) {
+  let arguments;
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

src/direct-eval-code/default/async-func-decl/fn-body-cntns-arguments-var-bind.template

@@ -0,0 +1,21 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-func-decl-fn-body-cntns-arguments-var-bind-
+name: Declare |arguments| when the function body contains an |arguments| var-binding.
+esid: sec-evaldeclarationinstantiation
+flags: [async,noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+async function f(p = /*{ parameter-code }*/) {
+  var arguments;
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

src/direct-eval-code/default/async-func-decl/no-pre-existing-arguments-bindings-are-present.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-func-decl-no-pre-existing-arguments-bindings-are-present-
+name: Declare |arguments| when no pre-existing |arguments| bindings are present.
+esid: sec-evaldeclarationinstantiation
+flags: [async,noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+async function f(p = /*{ parameter-code }*/) {}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

src/direct-eval-code/default/async-func-expr-named/a-following-parameter-is-named-arguments.template

@@ -0,0 +1,22 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-func-expr-named-a-following-parameter-is-named-arguments-
+name: Declare |arguments| when a following parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [async,noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function f(p = /*{ parameter-code }*/, arguments) {
+  /*{ body }*/
+};
+f().then($DONE, error => {
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+  assert(error instanceof SyntaxError);
+}).then($DONE, $DONE);
+

src/direct-eval-code/default/async-func-expr-named/a-preceding-parameter-is-named-arguments.template

@@ -0,0 +1,22 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-func-expr-named-a-preceding-parameter-is-named-arguments-
+name: Declare |arguments| when a preceding parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [async,noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function f(arguments, p = /*{ parameter-code }*/) {
+  /*{ body }*/
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);
+

src/direct-eval-code/default/async-func-expr-named/fn-body-cntns-arguments-func-decl.template

@@ -0,0 +1,22 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-func-expr-named-fn-body-cntns-arguments-func-decl-
+name: Declare |arguments| when the function body contains an |arguments| function declaration.
+esid: sec-evaldeclarationinstantiation
+flags: [async,noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function f(p = /*{ parameter-code }*/) {
+  function arguments() {}
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);
+

src/direct-eval-code/default/async-func-expr-named/fn-body-cntns-arguments-lex-bind.template

@@ -0,0 +1,22 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-func-expr-named-fn-body-cntns-arguments-lex-bind-
+name: Declare |arguments| when the function body contains an |arguments| lexical binding.
+esid: sec-evaldeclarationinstantiation
+flags: [async,noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function f(p = /*{ parameter-code }*/) {
+  let arguments;
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);
+

src/direct-eval-code/default/async-func-expr-named/fn-body-cntns-arguments-var-bind.template

@@ -0,0 +1,22 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-func-expr-named-fn-body-cntns-arguments-var-bind-
+name: Declare |arguments| when the function body contains an |arguments| var-binding.
+esid: sec-evaldeclarationinstantiation
+flags: [async,noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function f(p = /*{ parameter-code }*/) {
+  var arguments;
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);
+

src/direct-eval-code/default/async-func-expr-named/no-pre-existing-arguments-bindings-are-present.template

@@ -0,0 +1,20 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-func-expr-named-no-pre-existing-arguments-bindings-are-present-
+name: Declare |arguments| when no pre-existing |arguments| bindings are present.
+esid: sec-evaldeclarationinstantiation
+flags: [async,noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function f(p = /*{ parameter-code }*/) {}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);
+

src/direct-eval-code/default/async-func-expr-nameless/a-following-parameter-is-named-arguments.template

@@ -0,0 +1,21 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-func-expr-nameless-a-following-parameter-is-named-arguments-
+name: Declare |arguments| when a following parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [async,noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function(p = /*{ parameter-code }*/, arguments) {
+  /*{ body }*/
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

src/direct-eval-code/default/async-func-expr-nameless/a-preceding-parameter-is-named-arguments.template

@@ -0,0 +1,21 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-func-expr-nameless-a-preceding-parameter-is-named-arguments-
+name: Declare |arguments| when a preceding parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [async,noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function(arguments, p = /*{ parameter-code }*/) {
+  /*{ body }*/
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

src/direct-eval-code/default/async-func-expr-nameless/fn-body-cntns-arguments-func-decl.template

@@ -0,0 +1,21 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-func-expr-nameless-fn-body-cntns-arguments-func-decl-
+name: Declare |arguments| when the function body contains an |arguments| function declaration.
+esid: sec-evaldeclarationinstantiation
+flags: [async,noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function(p = /*{ parameter-code }*/) {
+  function arguments() {}
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

src/direct-eval-code/default/async-func-expr-nameless/fn-body-cntns-arguments-lex-bind.template

@@ -0,0 +1,21 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-func-expr-nameless-fn-body-cntns-arguments-lex-bind-
+name: Declare |arguments| when the function body contains an |arguments| lexical binding.
+esid: sec-evaldeclarationinstantiation
+flags: [async,noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function(p = /*{ parameter-code }*/) {
+  let arguments;
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

src/direct-eval-code/default/async-func-expr-nameless/fn-body-cntns-arguments-var-bind.template

@@ -0,0 +1,21 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-func-expr-nameless-fn-body-cntns-arguments-var-bind-
+name: Declare |arguments| when the function body contains an |arguments| var-binding.
+esid: sec-evaldeclarationinstantiation
+flags: [async,noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function(p = /*{ parameter-code }*/) {
+  var arguments;
+}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

src/direct-eval-code/default/async-func-expr-nameless/no-pre-existing-arguments-bindings-are-present.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-func-expr-nameless-no-pre-existing-arguments-bindings-are-present-
+name: Declare |arguments| when no pre-existing |arguments| bindings are present.
+esid: sec-evaldeclarationinstantiation
+flags: [async,noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function(p = /*{ parameter-code }*/) {}
+f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

src/direct-eval-code/default/async-gen-func-decl/a-following-parameter-is-named-arguments.template

@@ -0,0 +1,20 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-gen-func-decl-a-following-parameter-is-named-arguments-
+name: Declare |arguments| when a following parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+async function * f(p = /*{ parameter-code }*/, arguments) {
+  /*{ body }*/
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/default/async-gen-func-decl/a-preceding-parameter-is-named-arguments.template

@@ -0,0 +1,20 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-gen-func-decl-a-preceding-parameter-is-named-arguments-
+name: Declare |arguments| when a preceding parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+async function * f(arguments, p = /*{ parameter-code }*/) {
+  /*{ body }*/
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/default/async-gen-func-decl/fn-body-cntns-arguments-func-decl.template

@@ -0,0 +1,20 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-gen-func-decl-fn-body-cntns-arguments-func-decl-
+name: Declare |arguments| when the function body contains an |arguments| function declaration.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+async function * f(p = /*{ parameter-code }*/) {
+  function arguments() {}
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/default/async-gen-func-decl/fn-body-cntns-arguments-lex-bind.template

@@ -0,0 +1,20 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-gen-func-decl-fn-body-cntns-arguments-lex-bind-
+name: Declare |arguments| when the function body contains an |arguments| lexical binding.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+async function * f(p = /*{ parameter-code }*/) {
+  let arguments;
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/default/async-gen-func-decl/fn-body-cntns-arguments-var-bind.template

@@ -0,0 +1,20 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-gen-func-decl-fn-body-cntns-arguments-var-bind-
+name: Declare |arguments| when the function body contains an |arguments| var-binding.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+async function * f(p = /*{ parameter-code }*/) {
+  var arguments;
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/default/async-gen-func-decl/no-pre-existing-arguments-bindings-are-present.template

@@ -0,0 +1,18 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-gen-func-decl-no-pre-existing-arguments-bindings-are-present-
+name: Declare |arguments| when no pre-existing |arguments| bindings are present.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+async function * f(p = /*{ parameter-code }*/) {}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/default/async-gen-func-expr/a-following-parameter-is-named-arguments.template

@@ -0,0 +1,20 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-gen-func-expr-a-following-parameter-is-named-arguments-
+name: Declare |arguments| when a following parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * (p = /*{ parameter-code }*/, arguments) {
+  /*{ body }*/
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/default/async-gen-func-expr/a-preceding-parameter-is-named-arguments.template

@@ -0,0 +1,20 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-gen-func-expr-a-preceding-parameter-is-named-arguments-
+name: Declare |arguments| when a preceding parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * (arguments, p = /*{ parameter-code }*/) {
+  /*{ body }*/
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/default/async-gen-func-expr/fn-body-cntns-arguments-func-decl.template

@@ -0,0 +1,20 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-gen-func-expr-fn-body-cntns-arguments-func-decl-
+name: Declare |arguments| when the function body contains an |arguments| function declaration.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * (p = /*{ parameter-code }*/) {
+  function arguments() {}
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/default/async-gen-func-expr/fn-body-cntns-arguments-lex-bind.template

@@ -0,0 +1,20 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-gen-func-expr-fn-body-cntns-arguments-lex-bind-
+name: Declare |arguments| when the function body contains an |arguments| lexical binding.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * (p = /*{ parameter-code }*/) {
+  let arguments;
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/default/async-gen-func-expr/fn-body-cntns-arguments-var-bind.template

@@ -0,0 +1,20 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-gen-func-expr-fn-body-cntns-arguments-var-bind-
+name: Declare |arguments| when the function body contains an |arguments| var-binding.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * (p = /*{ parameter-code }*/) {
+  var arguments;
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/default/async-gen-func-expr/no-pre-existing-arguments-bindings-are-present.template

@@ -0,0 +1,18 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-gen-func-expr-no-pre-existing-arguments-bindings-are-present-
+name: Declare |arguments| when no pre-existing |arguments| bindings are present.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * (p = /*{ parameter-code }*/) {}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/default/async-gen-meth/a-following-parameter-is-named-arguments.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-gen-meth-a-following-parameter-is-named-arguments-
+name: Declare |arguments| when a following parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let o = { async *f(p = /*{ parameter-code }*/, arguments) {
+  /*{ body }*/
+}};
+assert.throws(SyntaxError, o.f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/default/async-gen-meth/a-preceding-parameter-is-named-arguments.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-gen-meth-a-preceding-parameter-is-named-arguments-
+name: Declare |arguments| when a preceding parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let o = { async *f(arguments, p = /*{ parameter-code }*/) {
+  /*{ body }*/
+}};
+assert.throws(SyntaxError, o.f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/default/async-gen-meth/fn-body-cntns-arguments-func-decl.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-gen-meth-fn-body-cntns-arguments-func-decl-
+name: Declare |arguments| when the function body contains an |arguments| function declaration.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let o = { async *f(p = /*{ parameter-code }*/) {
+  function arguments() {}
+}};
+assert.throws(SyntaxError, o.f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/default/async-gen-meth/fn-body-cntns-arguments-lex-bind.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-gen-meth-fn-body-cntns-arguments-lex-bind-
+name: Declare |arguments| when the function body contains an |arguments| lexical binding.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let o = { async *f(p = /*{ parameter-code }*/) {
+  let arguments;
+}};
+assert.throws(SyntaxError, o.f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/default/async-gen-meth/fn-body-cntns-arguments-var-bind.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-gen-meth-fn-body-cntns-arguments-var-bind-
+name: Declare |arguments| when the function body contains an |arguments| var-binding.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let o = { async *f(p = /*{ parameter-code }*/) {
+  var arguments;
+}};
+assert.throws(SyntaxError, o.f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/default/async-gen-meth/no-pre-existing-arguments-bindings-are-present.template

@@ -0,0 +1,17 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-gen-meth-no-pre-existing-arguments-bindings-are-present-
+name: Declare |arguments| when no pre-existing |arguments| bindings are present.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let o = { async *f(p = /*{ parameter-code }*/) {}};
+assert.throws(SyntaxError, o.f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/default/async-gen-named-func-expr/a-following-parameter-is-named-arguments.template

@@ -0,0 +1,20 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-gen-named-func-expr-a-following-parameter-is-named-arguments-
+name: Declare |arguments| when a following parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * f(p = /*{ parameter-code }*/, arguments) {
+  /*{ body }*/
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/default/async-gen-named-func-expr/a-preceding-parameter-is-named-arguments.template

@@ -0,0 +1,20 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-gen-named-func-expr-a-preceding-parameter-is-named-arguments-
+name: Declare |arguments| when a preceding parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * f(arguments, p = /*{ parameter-code }*/) {
+  /*{ body }*/
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/default/async-gen-named-func-expr/fn-body-cntns-arguments-func-decl.template

@@ -0,0 +1,20 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-gen-named-func-expr-fn-body-cntns-arguments-func-decl-
+name: Declare |arguments| when the function body contains an |arguments| function declaration.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * f(p = /*{ parameter-code }*/) {
+  function arguments() {}
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/default/async-gen-named-func-expr/fn-body-cntns-arguments-lex-bind.template

@@ -0,0 +1,21 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-gen-named-func-expr-fn-body-cntns-arguments-lex-bind-
+name: Declare |arguments| when the function body contains an |arguments| lexical binding.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * f(p = /*{ parameter-code }*/) {
+  let arguments;
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+

src/direct-eval-code/default/async-gen-named-func-expr/fn-body-cntns-arguments-var-bind.template

@@ -0,0 +1,20 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-gen-named-func-expr-fn-body-cntns-arguments-var-bind-
+name: Declare |arguments| when the function body contains an |arguments| var-binding.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * f(p = /*{ parameter-code }*/) {
+  var arguments;
+}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/default/async-gen-named-func-expr/no-pre-existing-arguments-bindings-are-present.template

@@ -0,0 +1,18 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-gen-named-func-expr-no-pre-existing-arguments-bindings-are-present-
+name: Declare |arguments| when no pre-existing |arguments| bindings are present.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let f = async function * f(p = /*{ parameter-code }*/) {}
+
+assert.throws(SyntaxError, f);
+assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");

src/direct-eval-code/default/async-meth/a-following-parameter-is-named-arguments.template

@@ -0,0 +1,21 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-meth-a-following-parameter-is-named-arguments-
+name: Declare |arguments| when a following parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [async,noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let o = { async f(p = /*{ parameter-code }*/, arguments) {
+  /*{ body }*/
+}};
+o.f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

src/direct-eval-code/default/async-meth/a-preceding-parameter-is-named-arguments.template

@@ -0,0 +1,21 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-meth-a-preceding-parameter-is-named-arguments-
+name: Declare |arguments| when a preceding parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [async,noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let o = { async f(arguments, p = /*{ parameter-code }*/) {
+  /*{ body }*/
+}};
+o.f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

src/direct-eval-code/default/async-meth/fn-body-cntns-arguments-func-decl.template

@@ -0,0 +1,21 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-meth-fn-body-cntns-arguments-func-decl-
+name: Declare |arguments| when the function body contains an |arguments| function declaration.
+esid: sec-evaldeclarationinstantiation
+flags: [async,noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let o = { async f(p = /*{ parameter-code }*/) {
+  function arguments() {}
+}};
+o.f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

src/direct-eval-code/default/async-meth/fn-body-cntns-arguments-lex-bind.template

@@ -0,0 +1,21 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-meth-fn-body-cntns-arguments-lex-bind-
+name: Declare |arguments| when the function body contains an |arguments| lexical binding.
+esid: sec-evaldeclarationinstantiation
+flags: [async,noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let o = { async f(p = /*{ parameter-code }*/) {
+  let arguments;
+}};
+o.f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

src/direct-eval-code/default/async-meth/fn-body-cntns-arguments-var-bind.template

@@ -0,0 +1,21 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-meth-fn-body-cntns-arguments-var-bind-
+name: Declare |arguments| when the function body contains an |arguments| var-binding.
+esid: sec-evaldeclarationinstantiation
+flags: [async,noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let o = { async f(p = /*{ parameter-code }*/) {
+  var arguments;
+}};
+o.f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

src/direct-eval-code/default/async-meth/no-pre-existing-arguments-bindings-are-present.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/async-meth-no-pre-existing-arguments-bindings-are-present-
+name: Declare |arguments| when no pre-existing |arguments| bindings are present.
+esid: sec-evaldeclarationinstantiation
+flags: [async,noStrict]
+features: [globalThis]
+---*/
+
+const oldArguments = globalThis.arguments;
+
+
+let o = { async f(p = /*{ parameter-code }*/) {}};
+o.f().then($DONE, error => {
+  assert(error instanceof SyntaxError);
+  assert.sameValue(globalThis.arguments, oldArguments, "globalThis.arguments unchanged");
+}).then($DONE, $DONE);

src/direct-eval-code/default/func-decl/a-following-parameter-is-named-arguments.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/func-decl-a-following-parameter-is-named-arguments-
+name: Declare |arguments| when a following parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+function f(p = /*{ parameter-code }*/, arguments) {
+  /*{ body }*/
+}
+assert.throws(SyntaxError, f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/func-decl/a-preceding-parameter-is-named-arguments.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/func-decl-a-preceding-parameter-is-named-arguments-
+name: Declare |arguments| when a preceding parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+function f(arguments, p = /*{ parameter-code }*/) {
+  /*{ body }*/
+}
+assert.throws(SyntaxError, f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/func-decl/fn-body-cntns-arguments-func-decl.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/func-decl-fn-body-cntns-arguments-func-decl-
+name: Declare |arguments| when the function body contains an |arguments| function declaration.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+function f(p = /*{ parameter-code }*/) {
+  function arguments() {}
+}
+assert.throws(SyntaxError, f);
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/func-decl/fn-body-cntns-arguments-lex-bind.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/func-decl-fn-body-cntns-arguments-lex-bind-
+name: Declare |arguments| when the function body contains an |arguments| lexical binding.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+function f(p = /*{ parameter-code }*/) {
+  let arguments;
+}
+assert.throws(SyntaxError, f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/func-decl/fn-body-cntns-arguments-var-bind.template

@@ -0,0 +1,18 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/func-decl-fn-body-cntns-arguments-var-bind-
+name: Declare |arguments| when the function body contains an |arguments| var-binding.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+function f(p = /*{ parameter-code }*/) {
+  var arguments;
+}
+assert.throws(SyntaxError, f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/func-decl/no-pre-existing-arguments-bindings-are-present.template

@@ -0,0 +1,16 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/func-decl-no-pre-existing-arguments-bindings-are-present-
+name: Declare |arguments| when no pre-existing |arguments| bindings are present.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+function f(p = /*{ parameter-code }*/) {}
+assert.throws(SyntaxError, f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/func-expr/a-following-parameter-is-named-arguments.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/func-expr-a-following-parameter-is-named-arguments-
+name: Declare |arguments| when a following parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let f = function(p = /*{ parameter-code }*/, arguments) {
+  /*{ body }*/
+}
+assert.throws(SyntaxError, f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/func-expr/a-preceding-parameter-is-named-arguments.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/func-expr-a-preceding-parameter-is-named-arguments-
+name: Declare |arguments| when a preceding parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let f = function(arguments, p = /*{ parameter-code }*/) {
+  /*{ body }*/
+}
+assert.throws(SyntaxError, f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/func-expr/fn-body-cntns-arguments-func-decl.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/func-expr-fn-body-cntns-arguments-func-decl-
+name: Declare |arguments| when the function body contains an |arguments| function declaration.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let f = function(p = /*{ parameter-code }*/) {
+  function arguments() {}
+}
+assert.throws(SyntaxError, f);
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/func-expr/fn-body-cntns-arguments-lex-bind.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/func-expr-fn-body-cntns-arguments-lex-bind-
+name: Declare |arguments| when the function body contains an |arguments| lexical binding.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let f = function(p = /*{ parameter-code }*/) {
+  let arguments;
+}
+assert.throws(SyntaxError, f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/func-expr/fn-body-cntns-arguments-var-bind.template

@@ -0,0 +1,18 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/func-expr-fn-body-cntns-arguments-var-bind-
+name: Declare |arguments| when the function body contains an |arguments| var-binding.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let f = function(p = /*{ parameter-code }*/) {
+  var arguments;
+}
+assert.throws(SyntaxError, f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/func-expr/no-pre-existing-arguments-bindings-are-present.template

@@ -0,0 +1,16 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/func-expr-no-pre-existing-arguments-bindings-are-present-
+name: Declare |arguments| when no pre-existing |arguments| bindings are present.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let f = function(p = /*{ parameter-code }*/) {}
+assert.throws(SyntaxError, f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/gen-func-decl/a-following-parameter-is-named-arguments.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/gen-func-decl-a-following-parameter-is-named-arguments-
+name: Declare |arguments| when a following parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+function * f(p = /*{ parameter-code }*/, arguments) {
+  /*{ body }*/
+}
+assert.throws(SyntaxError, f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/gen-func-decl/a-preceding-parameter-is-named-arguments.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/gen-func-decl-a-preceding-parameter-is-named-arguments-
+name: Declare |arguments| when a preceding parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+function * f(arguments, p = /*{ parameter-code }*/) {
+  /*{ body }*/
+}
+assert.throws(SyntaxError, f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/gen-func-decl/fn-body-cntns-arguments-func-decl.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/gen-func-decl-fn-body-cntns-arguments-func-decl-
+name: Declare |arguments| when the function body contains an |arguments| function declaration.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+function * f(p = /*{ parameter-code }*/) {
+  function arguments() {}
+}
+assert.throws(SyntaxError, f);
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/gen-func-decl/fn-body-cntns-arguments-lex-bind.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/gen-func-decl-fn-body-cntns-arguments-lex-bind-
+name: Declare |arguments| when the function body contains an |arguments| lexical binding.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+function * f(p = /*{ parameter-code }*/) {
+  let arguments;
+}
+assert.throws(SyntaxError, f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/gen-func-decl/fn-body-cntns-arguments-var-bind.template

@@ -0,0 +1,18 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/gen-func-decl-fn-body-cntns-arguments-var-bind-
+name: Declare |arguments| when the function body contains an |arguments| var-binding.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+function * f(p = /*{ parameter-code }*/) {
+  var arguments;
+}
+assert.throws(SyntaxError, f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/gen-func-decl/no-pre-existing-arguments-bindings-are-present.template

@@ -0,0 +1,16 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/gen-func-decl-no-pre-existing-arguments-bindings-are-present-
+name: Declare |arguments| when no pre-existing |arguments| bindings are present.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+function * f(p = /*{ parameter-code }*/) {}
+assert.throws(SyntaxError, f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/gen-func-expr-named/a-following-parameter-is-named-arguments.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/gen-func-expr-named-a-following-parameter-is-named-arguments-
+name: Declare |arguments| when a following parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let f = function * f(p = /*{ parameter-code }*/, arguments) {
+  /*{ body }*/
+}
+assert.throws(SyntaxError, f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/gen-func-expr-named/a-preceding-parameter-is-named-arguments.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/gen-func-expr-named-a-preceding-parameter-is-named-arguments-
+name: Declare |arguments| when a preceding parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let f = function * f(arguments, p = /*{ parameter-code }*/) {
+  /*{ body }*/
+}
+assert.throws(SyntaxError, f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/gen-func-expr-named/fn-body-cntns-arguments-func-decl.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/gen-func-expr-named-fn-body-cntns-arguments-func-decl-
+name: Declare |arguments| when the function body contains an |arguments| function declaration.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let f = function * f(p = /*{ parameter-code }*/) {
+  function arguments() {}
+}
+assert.throws(SyntaxError, f);
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/gen-func-expr-named/fn-body-cntns-arguments-lex-bind.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/gen-func-expr-named-fn-body-cntns-arguments-lex-bind-
+name: Declare |arguments| when the function body contains an |arguments| lexical binding.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let f = function * f(p = /*{ parameter-code }*/) {
+  let arguments;
+}
+assert.throws(SyntaxError, f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/gen-func-expr-named/fn-body-cntns-arguments-var-bind.template

@@ -0,0 +1,18 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/gen-func-expr-named-fn-body-cntns-arguments-var-bind-
+name: Declare |arguments| when the function body contains an |arguments| var-binding.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let f = function * f(p = /*{ parameter-code }*/) {
+  var arguments;
+}
+assert.throws(SyntaxError, f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/gen-func-expr-named/no-pre-existing-arguments-bindings-are-present.template

@@ -0,0 +1,16 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/gen-func-expr-named-no-pre-existing-arguments-bindings-are-present-
+name: Declare |arguments| when no pre-existing |arguments| bindings are present.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let f = function * f(p = /*{ parameter-code }*/) {}
+assert.throws(SyntaxError, f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/gen-func-expr-nameless/a-following-parameter-is-named-arguments.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/gen-func-expr-nameless-a-following-parameter-is-named-arguments-
+name: Declare |arguments| when a following parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let f = function * (p = /*{ parameter-code }*/, arguments) {
+  /*{ body }*/
+}
+assert.throws(SyntaxError, f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/gen-func-expr-nameless/a-preceding-parameter-is-named-arguments.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/gen-func-expr-nameless-a-preceding-parameter-is-named-arguments-
+name: Declare |arguments| when a preceding parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let f = function * (arguments, p = /*{ parameter-code }*/) {
+  /*{ body }*/
+}
+assert.throws(SyntaxError, f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/gen-func-expr-nameless/fn-body-cntns-arguments-func-decl.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/gen-func-expr-nameless-fn-body-cntns-arguments-func-decl-
+name: Declare |arguments| when the function body contains an |arguments| function declaration.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let f = function * (p = /*{ parameter-code }*/) {
+  function arguments() {}
+}
+assert.throws(SyntaxError, f);
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/gen-func-expr-nameless/fn-body-cntns-arguments-lex-bind.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/gen-func-expr-nameless-fn-body-cntns-arguments-lex-bind-
+name: Declare |arguments| when the function body contains an |arguments| lexical binding.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let f = function * (p = /*{ parameter-code }*/) {
+  let arguments;
+}
+assert.throws(SyntaxError, f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/gen-func-expr-nameless/fn-body-cntns-arguments-var-bind.template

@@ -0,0 +1,18 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/gen-func-expr-nameless-fn-body-cntns-arguments-var-bind-
+name: Declare |arguments| when the function body contains an |arguments| var-binding.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let f = function * (p = /*{ parameter-code }*/) {
+  var arguments;
+}
+assert.throws(SyntaxError, f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/gen-func-expr-nameless/no-pre-existing-arguments-bindings-are-present.template

@@ -0,0 +1,16 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/gen-func-expr-nameless-no-pre-existing-arguments-bindings-are-present-
+name: Declare |arguments| when no pre-existing |arguments| bindings are present.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let f = function * (p = /*{ parameter-code }*/) {}
+assert.throws(SyntaxError, f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/gen-meth/a-following-parameter-is-named-arguments.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/gen-meth-a-following-parameter-is-named-arguments-
+name: Declare |arguments| when a following parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let o = { * f(p = /*{ parameter-code }*/, arguments) {
+  /*{ body }*/
+}};
+assert.throws(SyntaxError, o.f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/gen-meth/a-preceding-parameter-is-named-arguments.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/gen-meth-a-preceding-parameter-is-named-arguments-
+name: Declare |arguments| when a preceding parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let o = { * f(arguments, p = /*{ parameter-code }*/) {
+  /*{ body }*/
+}};
+assert.throws(SyntaxError, o.f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/gen-meth/fn-body-cntns-arguments-func-decl.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/gen-meth-fn-body-cntns-arguments-func-decl-
+name: Declare |arguments| when the function body contains an |arguments| function declaration.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let o = { * f(p = /*{ parameter-code }*/) {
+  function arguments() {}
+}};
+assert.throws(SyntaxError, o.f);
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/gen-meth/fn-body-cntns-arguments-lex-bind.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/gen-meth-fn-body-cntns-arguments-lex-bind-
+name: Declare |arguments| when the function body contains an |arguments| lexical binding.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let o = { * f(p = /*{ parameter-code }*/) {
+  let arguments;
+}};
+assert.throws(SyntaxError, o.f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/gen-meth/fn-body-cntns-arguments-var-bind.template

@@ -0,0 +1,18 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/gen-meth-fn-body-cntns-arguments-var-bind-
+name: Declare |arguments| when the function body contains an |arguments| var-binding.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let o = { * f(p = /*{ parameter-code }*/) {
+  var arguments;
+}};
+assert.throws(SyntaxError, o.f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/gen-meth/no-pre-existing-arguments-bindings-are-present.template

@@ -0,0 +1,16 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/gen-meth-no-pre-existing-arguments-bindings-are-present-
+name: Declare |arguments| when no pre-existing |arguments| bindings are present.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let o = { * f(p = /*{ parameter-code }*/) {}};
+assert.throws(SyntaxError, o.f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/meth/a-following-parameter-is-named-arguments.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/meth-a-following-parameter-is-named-arguments-
+name: Declare |arguments| when a following parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let o = { f(p = /*{ parameter-code }*/, arguments) {
+  /*{ body }*/
+}};
+assert.throws(SyntaxError, o.f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/meth/a-preceding-parameter-is-named-arguments.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/meth-a-preceding-parameter-is-named-arguments-
+name: Declare |arguments| when a preceding parameter is named |arguments|.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let o = { f(arguments, p = /*{ parameter-code }*/) {
+  /*{ body }*/
+}};
+assert.throws(SyntaxError, o.f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/meth/fn-body-cntns-arguments-func-decl.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/meth-fn-body-cntns-arguments-func-decl-
+name: Declare |arguments| when the function body contains an |arguments| function declaration.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let o = { f(p = /*{ parameter-code }*/) {
+  function arguments() {}
+}};
+assert.throws(SyntaxError, o.f);
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/meth/fn-body-cntns-arguments-lex-bind.template

@@ -0,0 +1,19 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/meth-fn-body-cntns-arguments-lex-bind-
+name: Declare |arguments| when the function body contains an |arguments| lexical binding.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let o = { f(p = /*{ parameter-code }*/) {
+  let arguments;
+}};
+assert.throws(SyntaxError, o.f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");

src/direct-eval-code/default/meth/fn-body-cntns-arguments-var-bind.template

@@ -0,0 +1,18 @@
+// Copyright (C) 2020 Rick Waldron, André Bargull. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/eval-code/direct/meth-fn-body-cntns-arguments-var-bind-
+name: Declare |arguments| when the function body contains an |arguments| var-binding.
+esid: sec-evaldeclarationinstantiation
+flags: [noStrict]
+---*/
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");
+
+let o = { f(p = /*{ parameter-code }*/) {
+  var arguments;
+}};
+assert.throws(SyntaxError, o.f);
+
+assert.sameValue("arguments" in this, false, "No global 'arguments' binding");