diff --git a/src/direct-eval-code/arrow-func-declare-arguments-assign-incl-def-param-arrow-arguments.case b/src/direct-eval-code/arrow-func-declare-arguments-assign-incl-def-param-arrow-arguments.case
new file mode 100644
index 0000000000..c9afa56f0f
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/arrow-func-declare-arguments-assign.case b/src/direct-eval-code/arrow-func-declare-arguments-assign.case
new file mode 100644
index 0000000000..6c64e392f8
--- /dev/null
+++ b/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'")
diff --git a/src/direct-eval-code/arrow-func/a-following-parameter-is-named-arguments.template b/src/direct-eval-code/arrow-func/a-following-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..59ca5008be
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/arrow-func/a-preceding-parameter-is-named-arguments.template b/src/direct-eval-code/arrow-func/a-preceding-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..93106ef33a
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/arrow-func/fn-body-cntns-arguments-fn-decl-params-cntns-dflt-assignment.template b/src/direct-eval-code/arrow-func/fn-body-cntns-arguments-fn-decl-params-cntns-dflt-assignment.template
new file mode 100644
index 0000000000..eccd6acb35
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/arrow-func/fn-body-cntns-arguments-func-decl.template b/src/direct-eval-code/arrow-func/fn-body-cntns-arguments-func-decl.template
new file mode 100644
index 0000000000..e4561a4473
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/arrow-func/fn-body-cntns-arguments-lex-bind.template b/src/direct-eval-code/arrow-func/fn-body-cntns-arguments-lex-bind.template
new file mode 100644
index 0000000000..2b3a0af4c2
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/arrow-func/fn-body-cntns-arguments-var-bind.template b/src/direct-eval-code/arrow-func/fn-body-cntns-arguments-var-bind.template
new file mode 100644
index 0000000000..6895370082
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/arrow-func/no-pre-existing-arguments-bindings-are-present.template b/src/direct-eval-code/arrow-func/no-pre-existing-arguments-bindings-are-present.template
new file mode 100644
index 0000000000..0e316fd9f1
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/declare-arguments-and-assign.case b/src/direct-eval-code/declare-arguments-and-assign.case
new file mode 100644
index 0000000000..c8cf1e6818
--- /dev/null
+++ b/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'")
diff --git a/src/direct-eval-code/declare-arguments.case b/src/direct-eval-code/declare-arguments.case
new file mode 100644
index 0000000000..a9e808e40e
--- /dev/null
+++ b/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")
diff --git a/src/direct-eval-code/default/async-func-decl/a-following-parameter-is-named-arguments.template b/src/direct-eval-code/default/async-func-decl/a-following-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..9a53b0b67f
--- /dev/null
+++ b/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);
+
diff --git a/src/direct-eval-code/default/async-func-decl/a-preceding-parameter-is-named-arguments.template b/src/direct-eval-code/default/async-func-decl/a-preceding-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..deea365491
--- /dev/null
+++ b/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);
+
diff --git a/src/direct-eval-code/default/async-func-decl/fn-body-cntns-arguments-func-decl.template b/src/direct-eval-code/default/async-func-decl/fn-body-cntns-arguments-func-decl.template
new file mode 100644
index 0000000000..48cb62ca26
--- /dev/null
+++ b/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);
diff --git a/src/direct-eval-code/default/async-func-decl/fn-body-cntns-arguments-lex-bind.template b/src/direct-eval-code/default/async-func-decl/fn-body-cntns-arguments-lex-bind.template
new file mode 100644
index 0000000000..790bef0dee
--- /dev/null
+++ b/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);
diff --git a/src/direct-eval-code/default/async-func-decl/fn-body-cntns-arguments-var-bind.template b/src/direct-eval-code/default/async-func-decl/fn-body-cntns-arguments-var-bind.template
new file mode 100644
index 0000000000..c10c668bdf
--- /dev/null
+++ b/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);
diff --git a/src/direct-eval-code/default/async-func-decl/no-pre-existing-arguments-bindings-are-present.template b/src/direct-eval-code/default/async-func-decl/no-pre-existing-arguments-bindings-are-present.template
new file mode 100644
index 0000000000..c154591cd0
--- /dev/null
+++ b/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);
diff --git a/src/direct-eval-code/default/async-func-expr-named/a-following-parameter-is-named-arguments.template b/src/direct-eval-code/default/async-func-expr-named/a-following-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..ec39e95d35
--- /dev/null
+++ b/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);
+
diff --git a/src/direct-eval-code/default/async-func-expr-named/a-preceding-parameter-is-named-arguments.template b/src/direct-eval-code/default/async-func-expr-named/a-preceding-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..785bccd1cd
--- /dev/null
+++ b/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);
+
diff --git a/src/direct-eval-code/default/async-func-expr-named/fn-body-cntns-arguments-func-decl.template b/src/direct-eval-code/default/async-func-expr-named/fn-body-cntns-arguments-func-decl.template
new file mode 100644
index 0000000000..b65c93cae4
--- /dev/null
+++ b/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);
+
diff --git a/src/direct-eval-code/default/async-func-expr-named/fn-body-cntns-arguments-lex-bind.template b/src/direct-eval-code/default/async-func-expr-named/fn-body-cntns-arguments-lex-bind.template
new file mode 100644
index 0000000000..e3c06dd602
--- /dev/null
+++ b/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);
+
diff --git a/src/direct-eval-code/default/async-func-expr-named/fn-body-cntns-arguments-var-bind.template b/src/direct-eval-code/default/async-func-expr-named/fn-body-cntns-arguments-var-bind.template
new file mode 100644
index 0000000000..c13d64df97
--- /dev/null
+++ b/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);
+
diff --git a/src/direct-eval-code/default/async-func-expr-named/no-pre-existing-arguments-bindings-are-present.template b/src/direct-eval-code/default/async-func-expr-named/no-pre-existing-arguments-bindings-are-present.template
new file mode 100644
index 0000000000..da7352a719
--- /dev/null
+++ b/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);
+
diff --git a/src/direct-eval-code/default/async-func-expr-nameless/a-following-parameter-is-named-arguments.template b/src/direct-eval-code/default/async-func-expr-nameless/a-following-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..90f343625d
--- /dev/null
+++ b/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);
diff --git a/src/direct-eval-code/default/async-func-expr-nameless/a-preceding-parameter-is-named-arguments.template b/src/direct-eval-code/default/async-func-expr-nameless/a-preceding-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..99480c4dfe
--- /dev/null
+++ b/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);
diff --git a/src/direct-eval-code/default/async-func-expr-nameless/fn-body-cntns-arguments-func-decl.template b/src/direct-eval-code/default/async-func-expr-nameless/fn-body-cntns-arguments-func-decl.template
new file mode 100644
index 0000000000..e8df5ec3cc
--- /dev/null
+++ b/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);
diff --git a/src/direct-eval-code/default/async-func-expr-nameless/fn-body-cntns-arguments-lex-bind.template b/src/direct-eval-code/default/async-func-expr-nameless/fn-body-cntns-arguments-lex-bind.template
new file mode 100644
index 0000000000..c943ae7ce2
--- /dev/null
+++ b/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);
diff --git a/src/direct-eval-code/default/async-func-expr-nameless/fn-body-cntns-arguments-var-bind.template b/src/direct-eval-code/default/async-func-expr-nameless/fn-body-cntns-arguments-var-bind.template
new file mode 100644
index 0000000000..16f1ff849b
--- /dev/null
+++ b/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);
diff --git a/src/direct-eval-code/default/async-func-expr-nameless/no-pre-existing-arguments-bindings-are-present.template b/src/direct-eval-code/default/async-func-expr-nameless/no-pre-existing-arguments-bindings-are-present.template
new file mode 100644
index 0000000000..d266ef9cbc
--- /dev/null
+++ b/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);
diff --git a/src/direct-eval-code/default/async-gen-func-decl/a-following-parameter-is-named-arguments.template b/src/direct-eval-code/default/async-gen-func-decl/a-following-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..5e3d8ee067
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/async-gen-func-decl/a-preceding-parameter-is-named-arguments.template b/src/direct-eval-code/default/async-gen-func-decl/a-preceding-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..5d3d4985bd
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/async-gen-func-decl/fn-body-cntns-arguments-func-decl.template b/src/direct-eval-code/default/async-gen-func-decl/fn-body-cntns-arguments-func-decl.template
new file mode 100644
index 0000000000..c80574072e
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/async-gen-func-decl/fn-body-cntns-arguments-lex-bind.template b/src/direct-eval-code/default/async-gen-func-decl/fn-body-cntns-arguments-lex-bind.template
new file mode 100644
index 0000000000..38af18b91d
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/async-gen-func-decl/fn-body-cntns-arguments-var-bind.template b/src/direct-eval-code/default/async-gen-func-decl/fn-body-cntns-arguments-var-bind.template
new file mode 100644
index 0000000000..bec59b3c09
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/async-gen-func-decl/no-pre-existing-arguments-bindings-are-present.template b/src/direct-eval-code/default/async-gen-func-decl/no-pre-existing-arguments-bindings-are-present.template
new file mode 100644
index 0000000000..c4d59a7e79
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/async-gen-func-expr/a-following-parameter-is-named-arguments.template b/src/direct-eval-code/default/async-gen-func-expr/a-following-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..8aaa4222e4
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/async-gen-func-expr/a-preceding-parameter-is-named-arguments.template b/src/direct-eval-code/default/async-gen-func-expr/a-preceding-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..94f83702a9
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/async-gen-func-expr/fn-body-cntns-arguments-func-decl.template b/src/direct-eval-code/default/async-gen-func-expr/fn-body-cntns-arguments-func-decl.template
new file mode 100644
index 0000000000..69bbb155d5
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/async-gen-func-expr/fn-body-cntns-arguments-lex-bind.template b/src/direct-eval-code/default/async-gen-func-expr/fn-body-cntns-arguments-lex-bind.template
new file mode 100644
index 0000000000..ce75ead70f
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/async-gen-func-expr/fn-body-cntns-arguments-var-bind.template b/src/direct-eval-code/default/async-gen-func-expr/fn-body-cntns-arguments-var-bind.template
new file mode 100644
index 0000000000..43aa577ab0
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/async-gen-func-expr/no-pre-existing-arguments-bindings-are-present.template b/src/direct-eval-code/default/async-gen-func-expr/no-pre-existing-arguments-bindings-are-present.template
new file mode 100644
index 0000000000..f88aff0ae2
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/async-gen-meth/a-following-parameter-is-named-arguments.template b/src/direct-eval-code/default/async-gen-meth/a-following-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..2982c367cb
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/async-gen-meth/a-preceding-parameter-is-named-arguments.template b/src/direct-eval-code/default/async-gen-meth/a-preceding-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..c2bcf4a22b
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/async-gen-meth/fn-body-cntns-arguments-func-decl.template b/src/direct-eval-code/default/async-gen-meth/fn-body-cntns-arguments-func-decl.template
new file mode 100644
index 0000000000..444eb48dd3
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/async-gen-meth/fn-body-cntns-arguments-lex-bind.template b/src/direct-eval-code/default/async-gen-meth/fn-body-cntns-arguments-lex-bind.template
new file mode 100644
index 0000000000..2209fce6f8
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/async-gen-meth/fn-body-cntns-arguments-var-bind.template b/src/direct-eval-code/default/async-gen-meth/fn-body-cntns-arguments-var-bind.template
new file mode 100644
index 0000000000..71ba7e6f01
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/async-gen-meth/no-pre-existing-arguments-bindings-are-present.template b/src/direct-eval-code/default/async-gen-meth/no-pre-existing-arguments-bindings-are-present.template
new file mode 100644
index 0000000000..28c3f36fca
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/async-gen-named-func-expr/a-following-parameter-is-named-arguments.template b/src/direct-eval-code/default/async-gen-named-func-expr/a-following-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..12f048ad39
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/async-gen-named-func-expr/a-preceding-parameter-is-named-arguments.template b/src/direct-eval-code/default/async-gen-named-func-expr/a-preceding-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..1ddd2d3918
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/async-gen-named-func-expr/fn-body-cntns-arguments-func-decl.template b/src/direct-eval-code/default/async-gen-named-func-expr/fn-body-cntns-arguments-func-decl.template
new file mode 100644
index 0000000000..dc722d5f14
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/async-gen-named-func-expr/fn-body-cntns-arguments-lex-bind.template b/src/direct-eval-code/default/async-gen-named-func-expr/fn-body-cntns-arguments-lex-bind.template
new file mode 100644
index 0000000000..acf73d30f4
--- /dev/null
+++ b/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");
+
diff --git a/src/direct-eval-code/default/async-gen-named-func-expr/fn-body-cntns-arguments-var-bind.template b/src/direct-eval-code/default/async-gen-named-func-expr/fn-body-cntns-arguments-var-bind.template
new file mode 100644
index 0000000000..fded369cec
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/async-gen-named-func-expr/no-pre-existing-arguments-bindings-are-present.template b/src/direct-eval-code/default/async-gen-named-func-expr/no-pre-existing-arguments-bindings-are-present.template
new file mode 100644
index 0000000000..d413a2cbc6
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/async-meth/a-following-parameter-is-named-arguments.template b/src/direct-eval-code/default/async-meth/a-following-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..7905e44cb9
--- /dev/null
+++ b/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);
diff --git a/src/direct-eval-code/default/async-meth/a-preceding-parameter-is-named-arguments.template b/src/direct-eval-code/default/async-meth/a-preceding-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..595ec491c0
--- /dev/null
+++ b/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);
diff --git a/src/direct-eval-code/default/async-meth/fn-body-cntns-arguments-func-decl.template b/src/direct-eval-code/default/async-meth/fn-body-cntns-arguments-func-decl.template
new file mode 100644
index 0000000000..ed203249ee
--- /dev/null
+++ b/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);
diff --git a/src/direct-eval-code/default/async-meth/fn-body-cntns-arguments-lex-bind.template b/src/direct-eval-code/default/async-meth/fn-body-cntns-arguments-lex-bind.template
new file mode 100644
index 0000000000..3387696a34
--- /dev/null
+++ b/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);
diff --git a/src/direct-eval-code/default/async-meth/fn-body-cntns-arguments-var-bind.template b/src/direct-eval-code/default/async-meth/fn-body-cntns-arguments-var-bind.template
new file mode 100644
index 0000000000..0ffb0b4a5d
--- /dev/null
+++ b/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);
diff --git a/src/direct-eval-code/default/async-meth/no-pre-existing-arguments-bindings-are-present.template b/src/direct-eval-code/default/async-meth/no-pre-existing-arguments-bindings-are-present.template
new file mode 100644
index 0000000000..ab25b3e5ae
--- /dev/null
+++ b/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);
diff --git a/src/direct-eval-code/default/func-decl/a-following-parameter-is-named-arguments.template b/src/direct-eval-code/default/func-decl/a-following-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..32d87acdbb
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/func-decl/a-preceding-parameter-is-named-arguments.template b/src/direct-eval-code/default/func-decl/a-preceding-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..64457025d7
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/func-decl/fn-body-cntns-arguments-func-decl.template b/src/direct-eval-code/default/func-decl/fn-body-cntns-arguments-func-decl.template
new file mode 100644
index 0000000000..66da314820
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/func-decl/fn-body-cntns-arguments-lex-bind.template b/src/direct-eval-code/default/func-decl/fn-body-cntns-arguments-lex-bind.template
new file mode 100644
index 0000000000..7e7c4abd4d
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/func-decl/fn-body-cntns-arguments-var-bind.template b/src/direct-eval-code/default/func-decl/fn-body-cntns-arguments-var-bind.template
new file mode 100644
index 0000000000..7cf52f9a91
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/func-decl/no-pre-existing-arguments-bindings-are-present.template b/src/direct-eval-code/default/func-decl/no-pre-existing-arguments-bindings-are-present.template
new file mode 100644
index 0000000000..8cc0a3eca0
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/func-expr/a-following-parameter-is-named-arguments.template b/src/direct-eval-code/default/func-expr/a-following-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..05d8d6b1d5
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/func-expr/a-preceding-parameter-is-named-arguments.template b/src/direct-eval-code/default/func-expr/a-preceding-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..41912fbca5
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/func-expr/fn-body-cntns-arguments-func-decl.template b/src/direct-eval-code/default/func-expr/fn-body-cntns-arguments-func-decl.template
new file mode 100644
index 0000000000..2220932bcd
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/func-expr/fn-body-cntns-arguments-lex-bind.template b/src/direct-eval-code/default/func-expr/fn-body-cntns-arguments-lex-bind.template
new file mode 100644
index 0000000000..0fadb74afa
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/func-expr/fn-body-cntns-arguments-var-bind.template b/src/direct-eval-code/default/func-expr/fn-body-cntns-arguments-var-bind.template
new file mode 100644
index 0000000000..68c6df5cb4
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/func-expr/no-pre-existing-arguments-bindings-are-present.template b/src/direct-eval-code/default/func-expr/no-pre-existing-arguments-bindings-are-present.template
new file mode 100644
index 0000000000..547b5a5a44
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/gen-func-decl/a-following-parameter-is-named-arguments.template b/src/direct-eval-code/default/gen-func-decl/a-following-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..19f0c6b616
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/gen-func-decl/a-preceding-parameter-is-named-arguments.template b/src/direct-eval-code/default/gen-func-decl/a-preceding-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..fe13c54f3d
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/gen-func-decl/fn-body-cntns-arguments-func-decl.template b/src/direct-eval-code/default/gen-func-decl/fn-body-cntns-arguments-func-decl.template
new file mode 100644
index 0000000000..38fc2c47ce
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/gen-func-decl/fn-body-cntns-arguments-lex-bind.template b/src/direct-eval-code/default/gen-func-decl/fn-body-cntns-arguments-lex-bind.template
new file mode 100644
index 0000000000..28a46b8a60
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/gen-func-decl/fn-body-cntns-arguments-var-bind.template b/src/direct-eval-code/default/gen-func-decl/fn-body-cntns-arguments-var-bind.template
new file mode 100644
index 0000000000..8b1284796c
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/gen-func-decl/no-pre-existing-arguments-bindings-are-present.template b/src/direct-eval-code/default/gen-func-decl/no-pre-existing-arguments-bindings-are-present.template
new file mode 100644
index 0000000000..0f0117c3c2
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/gen-func-expr-named/a-following-parameter-is-named-arguments.template b/src/direct-eval-code/default/gen-func-expr-named/a-following-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..3e5e296c87
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/gen-func-expr-named/a-preceding-parameter-is-named-arguments.template b/src/direct-eval-code/default/gen-func-expr-named/a-preceding-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..b0953d66c8
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/gen-func-expr-named/fn-body-cntns-arguments-func-decl.template b/src/direct-eval-code/default/gen-func-expr-named/fn-body-cntns-arguments-func-decl.template
new file mode 100644
index 0000000000..55b9e77ae3
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/gen-func-expr-named/fn-body-cntns-arguments-lex-bind.template b/src/direct-eval-code/default/gen-func-expr-named/fn-body-cntns-arguments-lex-bind.template
new file mode 100644
index 0000000000..ca6d361134
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/gen-func-expr-named/fn-body-cntns-arguments-var-bind.template b/src/direct-eval-code/default/gen-func-expr-named/fn-body-cntns-arguments-var-bind.template
new file mode 100644
index 0000000000..4b7a07d31a
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/gen-func-expr-named/no-pre-existing-arguments-bindings-are-present.template b/src/direct-eval-code/default/gen-func-expr-named/no-pre-existing-arguments-bindings-are-present.template
new file mode 100644
index 0000000000..64b698fb70
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/gen-func-expr-nameless/a-following-parameter-is-named-arguments.template b/src/direct-eval-code/default/gen-func-expr-nameless/a-following-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..d12e53bd2d
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/gen-func-expr-nameless/a-preceding-parameter-is-named-arguments.template b/src/direct-eval-code/default/gen-func-expr-nameless/a-preceding-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..eaed93413d
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/gen-func-expr-nameless/fn-body-cntns-arguments-func-decl.template b/src/direct-eval-code/default/gen-func-expr-nameless/fn-body-cntns-arguments-func-decl.template
new file mode 100644
index 0000000000..6f242850c8
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/gen-func-expr-nameless/fn-body-cntns-arguments-lex-bind.template b/src/direct-eval-code/default/gen-func-expr-nameless/fn-body-cntns-arguments-lex-bind.template
new file mode 100644
index 0000000000..2df9e732e1
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/gen-func-expr-nameless/fn-body-cntns-arguments-var-bind.template b/src/direct-eval-code/default/gen-func-expr-nameless/fn-body-cntns-arguments-var-bind.template
new file mode 100644
index 0000000000..18b0a166f2
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/gen-func-expr-nameless/no-pre-existing-arguments-bindings-are-present.template b/src/direct-eval-code/default/gen-func-expr-nameless/no-pre-existing-arguments-bindings-are-present.template
new file mode 100644
index 0000000000..5f851a1b68
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/gen-meth/a-following-parameter-is-named-arguments.template b/src/direct-eval-code/default/gen-meth/a-following-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..37804ee461
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/gen-meth/a-preceding-parameter-is-named-arguments.template b/src/direct-eval-code/default/gen-meth/a-preceding-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..34fcfa2cd2
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/gen-meth/fn-body-cntns-arguments-func-decl.template b/src/direct-eval-code/default/gen-meth/fn-body-cntns-arguments-func-decl.template
new file mode 100644
index 0000000000..ba766e951f
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/gen-meth/fn-body-cntns-arguments-lex-bind.template b/src/direct-eval-code/default/gen-meth/fn-body-cntns-arguments-lex-bind.template
new file mode 100644
index 0000000000..e4b384192e
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/gen-meth/fn-body-cntns-arguments-var-bind.template b/src/direct-eval-code/default/gen-meth/fn-body-cntns-arguments-var-bind.template
new file mode 100644
index 0000000000..4ca55fdb0b
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/gen-meth/no-pre-existing-arguments-bindings-are-present.template b/src/direct-eval-code/default/gen-meth/no-pre-existing-arguments-bindings-are-present.template
new file mode 100644
index 0000000000..0039be641a
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/meth/a-following-parameter-is-named-arguments.template b/src/direct-eval-code/default/meth/a-following-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..fa08ad9afd
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/meth/a-preceding-parameter-is-named-arguments.template b/src/direct-eval-code/default/meth/a-preceding-parameter-is-named-arguments.template
new file mode 100644
index 0000000000..7db1f0b5df
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/meth/fn-body-cntns-arguments-func-decl.template b/src/direct-eval-code/default/meth/fn-body-cntns-arguments-func-decl.template
new file mode 100644
index 0000000000..ffaeefb743
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/meth/fn-body-cntns-arguments-lex-bind.template b/src/direct-eval-code/default/meth/fn-body-cntns-arguments-lex-bind.template
new file mode 100644
index 0000000000..d7a7fce37e
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/meth/fn-body-cntns-arguments-var-bind.template b/src/direct-eval-code/default/meth/fn-body-cntns-arguments-var-bind.template
new file mode 100644
index 0000000000..da6cb49bd0
--- /dev/null
+++ b/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");
diff --git a/src/direct-eval-code/default/meth/no-pre-existing-arguments-bindings-are-present.template b/src/direct-eval-code/default/meth/no-pre-existing-arguments-bindings-are-present.template
new file mode 100644
index 0000000000..aba99f4e61
--- /dev/null
+++ b/src/direct-eval-code/default/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/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");