From b89c3bf3694ce97a86900f2110edb2cc0fb28d8c Mon Sep 17 00:00:00 2001
From: Rick Waldron <waldron.rick@gmail.com>
Date: Fri, 9 Oct 2020 13:42:27 -0400
Subject: [PATCH] Generate tests

---
 ...bidden-ext-direct-access-prop-arguments.js | 20 ++++--
 ...forbidden-ext-direct-access-prop-caller.js | 20 ++++--
 ...ext-indirect-access-own-prop-caller-get.js | 60 ++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 60 ++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 46 ++++++++++---
 ...bidden-ext-direct-access-prop-arguments.js | 23 ++++---
 ...forbidden-ext-direct-access-prop-caller.js | 23 ++++---
 ...ext-indirect-access-own-prop-caller-get.js | 68 +++++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 68 +++++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 48 ++++++++++---
 ...bidden-ext-direct-access-prop-arguments.js | 23 ++++---
 ...forbidden-ext-direct-access-prop-caller.js | 23 ++++---
 ...bidden-ext-direct-access-prop-arguments.js | 23 ++++---
 ...forbidden-ext-direct-access-prop-caller.js | 23 ++++---
 ...ext-indirect-access-own-prop-caller-get.js | 64 +++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 64 +++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 51 ++++++++++----
 ...ext-indirect-access-own-prop-caller-get.js | 64 +++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 64 +++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 51 ++++++++++----
 ...bidden-ext-direct-access-prop-arguments.js | 23 ++++---
 ...forbidden-ext-direct-access-prop-caller.js | 23 ++++---
 ...bidden-ext-direct-access-prop-arguments.js | 23 ++++---
 ...forbidden-ext-direct-access-prop-caller.js | 23 ++++---
 ...ext-indirect-access-own-prop-caller-get.js | 64 +++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 64 +++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 48 ++++++++++---
 ...ext-indirect-access-own-prop-caller-get.js | 64 +++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 64 +++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 48 ++++++++++---
 ...bidden-ext-direct-access-prop-arguments.js | 23 ++++---
 ...forbidden-ext-direct-access-prop-caller.js | 23 ++++---
 ...ext-indirect-access-own-prop-caller-get.js | 63 +++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 63 +++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 48 ++++++++++---
 ...bidden-ext-direct-access-prop-arguments.js | 23 ++++---
 ...forbidden-ext-direct-access-prop-caller.js | 23 ++++---
 ...ext-indirect-access-own-prop-caller-get.js | 63 +++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 63 +++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 48 ++++++++++---
 ...bidden-ext-direct-access-prop-arguments.js | 23 ++++---
 ...forbidden-ext-direct-access-prop-caller.js | 23 ++++---
 ...ext-indirect-access-own-prop-caller-get.js | 65 ++++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 65 ++++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 48 ++++++++++---
 ...bidden-ext-direct-access-prop-arguments.js | 23 ++++---
 ...forbidden-ext-direct-access-prop-caller.js | 23 ++++---
 ...ext-indirect-access-own-prop-caller-get.js | 64 +++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 64 +++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 48 ++++++++++---
 ...bidden-ext-direct-access-prop-arguments.js | 21 ++++--
 ...forbidden-ext-direct-access-prop-caller.js | 21 ++++--
 ...ext-indirect-access-own-prop-caller-get.js | 61 +++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 61 +++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 46 ++++++++++---
 ...bidden-ext-direct-access-prop-arguments.js | 21 ++++--
 ...forbidden-ext-direct-access-prop-caller.js | 21 ++++--
 ...ext-indirect-access-own-prop-caller-get.js | 62 +++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 62 +++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 47 ++++++++++---
 ...bidden-ext-direct-access-prop-arguments.js | 21 ++++--
 ...forbidden-ext-direct-access-prop-caller.js | 21 ++++--
 ...ext-indirect-access-own-prop-caller-get.js | 62 +++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 62 +++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 47 ++++++++++---
 ...bidden-ext-direct-access-prop-arguments.js | 21 ++++--
 ...forbidden-ext-direct-access-prop-caller.js | 21 ++++--
 ...ext-indirect-access-own-prop-caller-get.js | 62 +++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 62 +++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 47 ++++++++++---
 ...bidden-ext-direct-access-prop-arguments.js | 26 -------
 ...forbidden-ext-direct-access-prop-caller.js | 26 -------
 ...bidden-ext-direct-access-prop-arguments.js | 20 ++++--
 ...forbidden-ext-direct-access-prop-caller.js | 20 ++++--
 ...ext-indirect-access-own-prop-caller-get.js | 59 ++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 59 ++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 46 ++++++++++---
 ...bidden-ext-direct-access-prop-arguments.js | 20 ++++--
 ...forbidden-ext-direct-access-prop-caller.js | 20 ++++--
 ...ext-indirect-access-own-prop-caller-get.js | 62 +++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 62 +++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 46 ++++++++++---
 ...bidden-ext-direct-access-prop-arguments.js | 23 ++++---
 ...forbidden-ext-direct-access-prop-caller.js | 23 ++++---
 ...bidden-ext-direct-access-prop-arguments.js | 23 ++++---
 ...forbidden-ext-direct-access-prop-caller.js | 23 ++++---
 ...bidden-ext-direct-access-prop-arguments.js | 19 ++++--
 ...forbidden-ext-direct-access-prop-caller.js | 19 ++++--
 ...bidden-ext-direct-access-prop-arguments.js | 19 ++++--
 ...forbidden-ext-direct-access-prop-caller.js | 19 ++++--
 ...ext-indirect-access-own-prop-caller-get.js | 65 ++++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 65 ++++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 48 ++++++++++---
 ...ext-indirect-access-own-prop-caller-get.js | 66 ++++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 66 ++++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 48 ++++++++++---
 ...ext-indirect-access-own-prop-caller-get.js | 62 +++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 62 +++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 44 +++++++++---
 ...ext-indirect-access-own-prop-caller-get.js | 60 ++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 60 ++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 45 +++++++++---
 ...bidden-ext-direct-access-prop-arguments.js | 23 ++++---
 ...forbidden-ext-direct-access-prop-caller.js | 23 ++++---
 ...ext-indirect-access-own-prop-caller-get.js | 63 +++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 63 +++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 48 ++++++++++---
 ...bidden-ext-direct-access-prop-arguments.js | 23 ++++---
 ...forbidden-ext-direct-access-prop-caller.js | 23 ++++---
 ...ext-indirect-access-own-prop-caller-get.js | 63 +++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 63 +++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 48 ++++++++++---
 ...bidden-ext-direct-access-prop-arguments.js | 23 ++++---
 ...forbidden-ext-direct-access-prop-caller.js | 23 ++++---
 ...ext-indirect-access-own-prop-caller-get.js | 64 +++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 64 +++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 48 ++++++++++---
 ...bidden-ext-direct-access-prop-arguments.js | 23 ++++---
 ...forbidden-ext-direct-access-prop-caller.js | 23 ++++---
 ...ext-indirect-access-own-prop-caller-get.js | 63 +++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 63 +++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 48 ++++++++++---
 ...bidden-ext-direct-access-prop-arguments.js | 23 ++++---
 ...forbidden-ext-direct-access-prop-caller.js | 23 ++++---
 ...ext-indirect-access-own-prop-caller-get.js | 64 +++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 64 +++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 48 ++++++++++---
 ...bidden-ext-direct-access-prop-arguments.js | 23 ++++---
 ...forbidden-ext-direct-access-prop-caller.js | 23 ++++---
 ...ext-indirect-access-own-prop-caller-get.js | 64 +++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 64 +++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 48 ++++++++++---
 ...bidden-ext-direct-access-prop-arguments.js | 21 ++++--
 ...forbidden-ext-direct-access-prop-caller.js | 21 ++++--
 ...ext-indirect-access-own-prop-caller-get.js | 62 +++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 62 +++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 46 ++++++++++---
 ...bidden-ext-direct-access-prop-arguments.js | 21 ++++--
 ...forbidden-ext-direct-access-prop-caller.js | 21 ++++--
 ...ext-indirect-access-own-prop-caller-get.js | 61 +++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 61 +++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 46 ++++++++++---
 ...bidden-ext-direct-access-prop-arguments.js | 21 ++++--
 ...forbidden-ext-direct-access-prop-caller.js | 21 ++++--
 ...ext-indirect-access-own-prop-caller-get.js | 61 +++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 61 +++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 46 ++++++++++---
 ...bidden-ext-direct-access-prop-arguments.js | 21 ++++--
 ...forbidden-ext-direct-access-prop-caller.js | 21 ++++--
 ...ext-indirect-access-own-prop-caller-get.js | 61 +++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 61 +++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 46 ++++++++++---
 ...bidden-ext-direct-access-prop-arguments.js | 20 ++++--
 ...forbidden-ext-direct-access-prop-caller.js | 20 ++++--
 ...bidden-ext-direct-access-prop-arguments.js | 25 -------
 ...forbidden-ext-direct-access-prop-caller.js | 25 -------
 ...ext-indirect-access-own-prop-caller-get.js | 59 ++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 59 ++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 46 ++++++++++---
 ...bidden-ext-direct-access-prop-arguments.js | 19 ++++--
 ...forbidden-ext-direct-access-prop-caller.js | 19 ++++--
 ...ext-indirect-access-own-prop-caller-get.js | 62 +++++++++++++++++
 ...t-indirect-access-own-prop-caller-value.js | 62 +++++++++++++++++
 ...rbidden-ext-indirect-access-prop-caller.js | 46 ++++++++++---
 164 files changed, 6113 insertions(+), 907 deletions(-)
 create mode 100644 test/language/expressions/arrow-function/forbidden-ext/b2/arrow-function-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/expressions/arrow-function/forbidden-ext/b2/arrow-function-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/expressions/async-arrow-function/forbidden-ext/b2/async-arrow-function-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/expressions/async-arrow-function/forbidden-ext/b2/async-arrow-function-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/expressions/async-function/forbidden-ext/b2/async-func-expr-named-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/expressions/async-function/forbidden-ext/b2/async-func-expr-named-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/expressions/async-function/forbidden-ext/b2/async-func-expr-nameless-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/expressions/async-function/forbidden-ext/b2/async-func-expr-nameless-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/expressions/async-generator/forbidden-ext/b2/async-gen-func-expr-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/expressions/async-generator/forbidden-ext/b2/async-gen-func-expr-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/expressions/async-generator/forbidden-ext/b2/async-gen-named-func-expr-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/expressions/async-generator/forbidden-ext/b2/async-gen-named-func-expr-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/expressions/class/async-gen-method-static/forbidden-ext/b2/cls-expr-async-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/expressions/class/async-gen-method-static/forbidden-ext/b2/cls-expr-async-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/expressions/class/async-gen-method/forbidden-ext/b2/cls-expr-async-gen-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/expressions/class/async-gen-method/forbidden-ext/b2/cls-expr-async-gen-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/expressions/class/async-method-static/forbidden-ext/b2/cls-expr-async-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/expressions/class/async-method-static/forbidden-ext/b2/cls-expr-async-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/expressions/class/async-method/forbidden-ext/b2/cls-expr-async-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/expressions/class/async-method/forbidden-ext/b2/cls-expr-async-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/expressions/class/gen-method-static/forbidden-ext/b2/cls-expr-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/expressions/class/gen-method-static/forbidden-ext/b2/cls-expr-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/expressions/class/gen-method/forbidden-ext/b2/cls-expr-gen-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/expressions/class/gen-method/forbidden-ext/b2/cls-expr-gen-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/expressions/class/method-static/forbidden-ext/b2/cls-expr-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/expressions/class/method-static/forbidden-ext/b2/cls-expr-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/expressions/class/method/forbidden-ext/b2/cls-expr-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/expressions/class/method/forbidden-ext/b2/cls-expr-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
 delete mode 100644 test/language/expressions/function/forbidden-ext/b1/func-expr-forbidden-ext-direct-access-prop-arguments.js
 delete mode 100644 test/language/expressions/function/forbidden-ext/b1/func-expr-forbidden-ext-direct-access-prop-caller.js
 create mode 100644 test/language/expressions/function/forbidden-ext/b2/func-expr-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/expressions/function/forbidden-ext/b2/func-expr-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/expressions/generators/forbidden-ext/b2/gen-func-expr-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/expressions/generators/forbidden-ext/b2/gen-func-expr-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/expressions/object/method-definition/forbidden-ext/b2/async-gen-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/expressions/object/method-definition/forbidden-ext/b2/async-gen-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/expressions/object/method-definition/forbidden-ext/b2/async-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/expressions/object/method-definition/forbidden-ext/b2/async-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/expressions/object/method-definition/forbidden-ext/b2/gen-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/expressions/object/method-definition/forbidden-ext/b2/gen-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/expressions/object/method-definition/forbidden-ext/b2/meth-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/expressions/object/method-definition/forbidden-ext/b2/meth-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/statements/async-function/forbidden-ext/b2/async-func-decl-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/statements/async-function/forbidden-ext/b2/async-func-decl-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/statements/async-generator/forbidden-ext/b2/async-gen-func-decl-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/statements/async-generator/forbidden-ext/b2/async-gen-func-decl-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/statements/class/async-gen-method-static/forbidden-ext/b2/cls-decl-async-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/statements/class/async-gen-method-static/forbidden-ext/b2/cls-decl-async-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/statements/class/async-gen-method/forbidden-ext/b2/cls-decl-async-gen-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/statements/class/async-gen-method/forbidden-ext/b2/cls-decl-async-gen-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/statements/class/async-method-static/forbidden-ext/b2/cls-decl-async-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/statements/class/async-method-static/forbidden-ext/b2/cls-decl-async-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/statements/class/async-method/forbidden-ext/b2/cls-decl-async-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/statements/class/async-method/forbidden-ext/b2/cls-decl-async-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/statements/class/gen-method-static/forbidden-ext/b2/cls-decl-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/statements/class/gen-method-static/forbidden-ext/b2/cls-decl-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/statements/class/gen-method/forbidden-ext/b2/cls-decl-gen-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/statements/class/gen-method/forbidden-ext/b2/cls-decl-gen-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/statements/class/method-static/forbidden-ext/b2/cls-decl-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/statements/class/method-static/forbidden-ext/b2/cls-decl-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/statements/class/method/forbidden-ext/b2/cls-decl-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/statements/class/method/forbidden-ext/b2/cls-decl-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
 delete mode 100644 test/language/statements/function/forbidden-ext/b1/func-decl-forbidden-ext-direct-access-prop-arguments.js
 delete mode 100644 test/language/statements/function/forbidden-ext/b1/func-decl-forbidden-ext-direct-access-prop-caller.js
 create mode 100644 test/language/statements/function/forbidden-ext/b2/func-decl-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/statements/function/forbidden-ext/b2/func-decl-forbidden-ext-indirect-access-own-prop-caller-value.js
 create mode 100644 test/language/statements/generators/forbidden-ext/b2/gen-func-decl-forbidden-ext-indirect-access-own-prop-caller-get.js
 create mode 100644 test/language/statements/generators/forbidden-ext/b2/gen-func-decl-forbidden-ext-indirect-access-own-prop-caller-value.js

diff --git a/test/language/expressions/arrow-function/forbidden-ext/b1/arrow-function-forbidden-ext-direct-access-prop-arguments.js b/test/language/expressions/arrow-function/forbidden-ext/b1/arrow-function-forbidden-ext-direct-access-prop-arguments.js
index 01c18ef780..21838706b0 100644
--- a/test/language/expressions/arrow-function/forbidden-ext/b1/arrow-function-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/expressions/arrow-function/forbidden-ext/b1/arrow-function-forbidden-ext-direct-access-prop-arguments.js
@@ -4,22 +4,32 @@
 /*---
 description: Forbidden extension, f.arguments (arrow function expression)
 esid: sec-arrow-function-definitions-runtime-semantics-evaluation
+features: [arrow-function]
 flags: [generated, noStrict]
 info: |
     ArrowFunction : ArrowParameters => ConciseBody
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 var f;
 f = () => {
-  f.arguments;
+  assert.sameValue(f.hasOwnProperty("arguments"), false);
   callCount++;
 };
 
-assert.throws(TypeError, function() {
+
   f();
-});
-assert.sameValue(callCount, 0, 'arrow function body not evaluated');
+assert.sameValue(callCount, 1, 'arrow function body evaluated');
diff --git a/test/language/expressions/arrow-function/forbidden-ext/b1/arrow-function-forbidden-ext-direct-access-prop-caller.js b/test/language/expressions/arrow-function/forbidden-ext/b1/arrow-function-forbidden-ext-direct-access-prop-caller.js
index 2dac570750..6ebf6ee102 100644
--- a/test/language/expressions/arrow-function/forbidden-ext/b1/arrow-function-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/expressions/arrow-function/forbidden-ext/b1/arrow-function-forbidden-ext-direct-access-prop-caller.js
@@ -4,22 +4,32 @@
 /*---
 description: Forbidden extension, o.caller (arrow function expression)
 esid: sec-arrow-function-definitions-runtime-semantics-evaluation
+features: [arrow-function]
 flags: [generated, noStrict]
 info: |
     ArrowFunction : ArrowParameters => ConciseBody
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 var f;
 f = () => {
-  f.caller;
+  assert.sameValue(f.hasOwnProperty("caller"), false);
   callCount++;
 };
 
-assert.throws(TypeError, function() {
+
   f();
-});
-assert.sameValue(callCount, 0, 'arrow function body not evaluated');
+assert.sameValue(callCount, 1, 'arrow function body evaluated');
diff --git a/test/language/expressions/arrow-function/forbidden-ext/b2/arrow-function-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/expressions/arrow-function/forbidden-ext/b2/arrow-function-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..3d949973ba
--- /dev/null
+++ b/test/language/expressions/arrow-function/forbidden-ext/b2/arrow-function-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,60 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/arrow-function.template
+/*---
+description: Forbidden extension, o.caller (arrow function expression)
+esid: sec-arrow-definitions-runtime-semantics-evaluation
+features: [arrow-function]
+flags: [generated, noStrict]
+info: |
+    ArrowFunction : ArrowParameters => ConciseBody
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+var f;
+f = () => {
+  "use strict";
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && true) {
+    Object.defineProperty(inner, "caller", {get(){return 1}});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && true) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+  callCount++;
+};
+
+f();
+assert.sameValue(callCount, 1, 'arrow function body evaluated');
diff --git a/test/language/expressions/arrow-function/forbidden-ext/b2/arrow-function-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/expressions/arrow-function/forbidden-ext/b2/arrow-function-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..7278a7749c
--- /dev/null
+++ b/test/language/expressions/arrow-function/forbidden-ext/b2/arrow-function-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,60 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/arrow-function.template
+/*---
+description: Forbidden extension, o.caller (arrow function expression)
+esid: sec-arrow-definitions-runtime-semantics-evaluation
+features: [arrow-function]
+flags: [generated, noStrict]
+info: |
+    ArrowFunction : ArrowParameters => ConciseBody
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+var f;
+f = () => {
+  "use strict";
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && true) {
+    Object.defineProperty(inner, "caller", {value: 1});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && true) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+  callCount++;
+};
+
+f();
+assert.sameValue(callCount, 1, 'arrow function body evaluated');
diff --git a/test/language/expressions/arrow-function/forbidden-ext/b2/arrow-function-forbidden-ext-indirect-access-prop-caller.js b/test/language/expressions/arrow-function/forbidden-ext/b2/arrow-function-forbidden-ext-indirect-access-prop-caller.js
index 7d48cb0951..e43be5056b 100644
--- a/test/language/expressions/arrow-function/forbidden-ext/b2/arrow-function-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/expressions/arrow-function/forbidden-ext/b2/arrow-function-forbidden-ext-indirect-access-prop-caller.js
@@ -4,27 +4,57 @@
 /*---
 description: Forbidden extension, o.caller (arrow function expression)
 esid: sec-arrow-definitions-runtime-semantics-evaluation
+features: [arrow-function]
 flags: [generated, noStrict]
 info: |
     ArrowFunction : ArrowParameters => ConciseBody
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 var callCount = 0;
 var f;
 f = () => {
   "use strict";
-  inner().toString();
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && false) {
+    Object.defineProperty(inner, "caller", {});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && false) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
   callCount++;
 };
 
-assert.throws(TypeError, function() {
-  f();
-});
-assert.sameValue(callCount, 0, 'arrow function body not evaluated');
+f();
+assert.sameValue(callCount, 1, 'arrow function body evaluated');
diff --git a/test/language/expressions/async-arrow-function/forbidden-ext/b1/async-arrow-function-forbidden-ext-direct-access-prop-arguments.js b/test/language/expressions/async-arrow-function/forbidden-ext/b1/async-arrow-function-forbidden-ext-direct-access-prop-arguments.js
index 658e83c94e..d440424ec6 100644
--- a/test/language/expressions/async-arrow-function/forbidden-ext/b1/async-arrow-function-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/expressions/async-arrow-function/forbidden-ext/b1/async-arrow-function-forbidden-ext-direct-access-prop-arguments.js
@@ -4,7 +4,7 @@
 /*---
 description: Forbidden extension, f.arguments (async arrow function expression)
 esid: sec-async-arrow-function-definitions
-features: [async-functions]
+features: [arrow-function, async-functions]
 flags: [generated, noStrict, async]
 info: |
     AsyncArrowFunction :
@@ -15,7 +15,16 @@ info: |
       { AsyncFunctionBody }
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
@@ -23,15 +32,11 @@ info: |
 var callCount = 0;
 var f;
 f = async () => {
-  f.arguments;
+  assert.sameValue(f.hasOwnProperty("arguments"), false);
   callCount++;
 };
 
 f()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/async-arrow-function/forbidden-ext/b1/async-arrow-function-forbidden-ext-direct-access-prop-caller.js b/test/language/expressions/async-arrow-function/forbidden-ext/b1/async-arrow-function-forbidden-ext-direct-access-prop-caller.js
index 436b0a3e7f..af5b651cfd 100644
--- a/test/language/expressions/async-arrow-function/forbidden-ext/b1/async-arrow-function-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/expressions/async-arrow-function/forbidden-ext/b1/async-arrow-function-forbidden-ext-direct-access-prop-caller.js
@@ -4,7 +4,7 @@
 /*---
 description: Forbidden extension, o.caller (async arrow function expression)
 esid: sec-async-arrow-function-definitions
-features: [async-functions]
+features: [arrow-function, async-functions]
 flags: [generated, noStrict, async]
 info: |
     AsyncArrowFunction :
@@ -15,7 +15,16 @@ info: |
       { AsyncFunctionBody }
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
@@ -23,15 +32,11 @@ info: |
 var callCount = 0;
 var f;
 f = async () => {
-  f.caller;
+  assert.sameValue(f.hasOwnProperty("caller"), false);
   callCount++;
 };
 
 f()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/async-arrow-function/forbidden-ext/b2/async-arrow-function-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/expressions/async-arrow-function/forbidden-ext/b2/async-arrow-function-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..86803cd805
--- /dev/null
+++ b/test/language/expressions/async-arrow-function/forbidden-ext/b2/async-arrow-function-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/async-arrow-function.template
+/*---
+description: Forbidden extension, o.caller (async arrow function expression)
+esid: sec-async-arrow-definitions
+features: [arrow-function, async-functions]
+flags: [generated, noStrict, async]
+info: |
+    AsyncArrowFunction :
+      ...
+      CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody
+
+    AsyncConciseBody :
+      { AsyncFunctionBody }
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+
+var callCount = 0;
+var f;
+f = async () => {
+  "use strict";
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && true) {
+    Object.defineProperty(inner, "caller", {get(){return 1}});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && true) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+  callCount++;
+};
+
+f()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/async-arrow-function/forbidden-ext/b2/async-arrow-function-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/expressions/async-arrow-function/forbidden-ext/b2/async-arrow-function-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..d0577f9b79
--- /dev/null
+++ b/test/language/expressions/async-arrow-function/forbidden-ext/b2/async-arrow-function-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,68 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/async-arrow-function.template
+/*---
+description: Forbidden extension, o.caller (async arrow function expression)
+esid: sec-async-arrow-definitions
+features: [arrow-function, async-functions]
+flags: [generated, noStrict, async]
+info: |
+    AsyncArrowFunction :
+      ...
+      CoverCallExpressionAndAsyncArrowHead => AsyncConciseBody
+
+    AsyncConciseBody :
+      { AsyncFunctionBody }
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+
+var callCount = 0;
+var f;
+f = async () => {
+  "use strict";
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && true) {
+    Object.defineProperty(inner, "caller", {value: 1});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && true) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+  callCount++;
+};
+
+f()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/async-arrow-function/forbidden-ext/b2/async-arrow-function-forbidden-ext-indirect-access-prop-caller.js b/test/language/expressions/async-arrow-function/forbidden-ext/b2/async-arrow-function-forbidden-ext-indirect-access-prop-caller.js
index d93f680e21..0e488f9bbc 100644
--- a/test/language/expressions/async-arrow-function/forbidden-ext/b2/async-arrow-function-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/expressions/async-arrow-function/forbidden-ext/b2/async-arrow-function-forbidden-ext-indirect-access-prop-caller.js
@@ -4,7 +4,7 @@
 /*---
 description: Forbidden extension, o.caller (async arrow function expression)
 esid: sec-async-arrow-definitions
-features: [async-functions]
+features: [arrow-function, async-functions]
 flags: [generated, noStrict, async]
 info: |
     AsyncArrowFunction :
@@ -15,12 +15,18 @@ info: |
       { AsyncFunctionBody }
 
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 
@@ -28,15 +34,35 @@ var callCount = 0;
 var f;
 f = async () => {
   "use strict";
-  inner().toString();
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && false) {
+    Object.defineProperty(inner, "caller", {});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && false) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
   callCount++;
 };
 
 f()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/async-function/forbidden-ext/b1/async-func-expr-named-forbidden-ext-direct-access-prop-arguments.js b/test/language/expressions/async-function/forbidden-ext/b1/async-func-expr-named-forbidden-ext-direct-access-prop-arguments.js
index dbf54fddcd..9c37c542f3 100644
--- a/test/language/expressions/async-function/forbidden-ext/b1/async-func-expr-named-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/expressions/async-function/forbidden-ext/b1/async-func-expr-named-forbidden-ext-direct-access-prop-arguments.js
@@ -4,29 +4,34 @@
 /*---
 description: Forbidden extension, f.arguments (async function named expression)
 esid: sec-async-function-definitions
-features: [async-functions]
+features: [arrow-function, async-functions]
 flags: [generated, noStrict, async]
 info: |
     AsyncFunctionExpression :
       async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody }
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 
 var callCount = 0;
 var f = async function f() {
-  f.arguments;
+  assert.sameValue(f.hasOwnProperty("arguments"), false);
   callCount++;
 }
 
 f()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/async-function/forbidden-ext/b1/async-func-expr-named-forbidden-ext-direct-access-prop-caller.js b/test/language/expressions/async-function/forbidden-ext/b1/async-func-expr-named-forbidden-ext-direct-access-prop-caller.js
index f1ec8118d2..01827a0886 100644
--- a/test/language/expressions/async-function/forbidden-ext/b1/async-func-expr-named-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/expressions/async-function/forbidden-ext/b1/async-func-expr-named-forbidden-ext-direct-access-prop-caller.js
@@ -4,29 +4,34 @@
 /*---
 description: Forbidden extension, o.caller (async function named expression)
 esid: sec-async-function-definitions
-features: [async-functions]
+features: [arrow-function, async-functions]
 flags: [generated, noStrict, async]
 info: |
     AsyncFunctionExpression :
       async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody }
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 
 var callCount = 0;
 var f = async function f() {
-  f.caller;
+  assert.sameValue(f.hasOwnProperty("caller"), false);
   callCount++;
 }
 
 f()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/async-function/forbidden-ext/b1/async-func-expr-nameless-forbidden-ext-direct-access-prop-arguments.js b/test/language/expressions/async-function/forbidden-ext/b1/async-func-expr-nameless-forbidden-ext-direct-access-prop-arguments.js
index d90e0c0824..7922d73059 100644
--- a/test/language/expressions/async-function/forbidden-ext/b1/async-func-expr-nameless-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/expressions/async-function/forbidden-ext/b1/async-func-expr-nameless-forbidden-ext-direct-access-prop-arguments.js
@@ -4,29 +4,34 @@
 /*---
 description: Forbidden extension, f.arguments (async function nameless expression)
 esid: sec-async-function-definitions
-features: [async-functions]
+features: [arrow-function, async-functions]
 flags: [generated, noStrict, async]
 info: |
     AsyncFunctionExpression :
       async function ( FormalParameters ) { AsyncFunctionBody }
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 
 var callCount = 0;
 var f = async function() {
-  f.arguments;
+  assert.sameValue(f.hasOwnProperty("arguments"), false);
   callCount++;
 }
 
 f()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/async-function/forbidden-ext/b1/async-func-expr-nameless-forbidden-ext-direct-access-prop-caller.js b/test/language/expressions/async-function/forbidden-ext/b1/async-func-expr-nameless-forbidden-ext-direct-access-prop-caller.js
index e22523857f..7e3f779cea 100644
--- a/test/language/expressions/async-function/forbidden-ext/b1/async-func-expr-nameless-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/expressions/async-function/forbidden-ext/b1/async-func-expr-nameless-forbidden-ext-direct-access-prop-caller.js
@@ -4,29 +4,34 @@
 /*---
 description: Forbidden extension, o.caller (async function nameless expression)
 esid: sec-async-function-definitions
-features: [async-functions]
+features: [arrow-function, async-functions]
 flags: [generated, noStrict, async]
 info: |
     AsyncFunctionExpression :
       async function ( FormalParameters ) { AsyncFunctionBody }
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 
 var callCount = 0;
 var f = async function() {
-  f.caller;
+  assert.sameValue(f.hasOwnProperty("caller"), false);
   callCount++;
 }
 
 f()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/async-function/forbidden-ext/b2/async-func-expr-named-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/expressions/async-function/forbidden-ext/b2/async-func-expr-named-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..1fdd0230f6
--- /dev/null
+++ b/test/language/expressions/async-function/forbidden-ext/b2/async-func-expr-named-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/async-func-expr-named.template
+/*---
+description: Forbidden extension, o.caller (async function named expression)
+esid: sec-async-definitions
+features: [arrow-function, async-functions]
+flags: [generated, noStrict, async]
+info: |
+    AsyncFunctionExpression :
+      async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody }
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+
+var callCount = 0;
+var f;
+f = async function f() {
+  "use strict";
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && true) {
+    Object.defineProperty(inner, "caller", {get(){return 1}});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && true) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+  callCount++;
+}
+
+f()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/async-function/forbidden-ext/b2/async-func-expr-named-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/expressions/async-function/forbidden-ext/b2/async-func-expr-named-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..03eb1afee9
--- /dev/null
+++ b/test/language/expressions/async-function/forbidden-ext/b2/async-func-expr-named-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/async-func-expr-named.template
+/*---
+description: Forbidden extension, o.caller (async function named expression)
+esid: sec-async-definitions
+features: [arrow-function, async-functions]
+flags: [generated, noStrict, async]
+info: |
+    AsyncFunctionExpression :
+      async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody }
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+
+var callCount = 0;
+var f;
+f = async function f() {
+  "use strict";
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && true) {
+    Object.defineProperty(inner, "caller", {value: 1});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && true) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+  callCount++;
+}
+
+f()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/async-function/forbidden-ext/b2/async-func-expr-named-forbidden-ext-indirect-access-prop-caller.js b/test/language/expressions/async-function/forbidden-ext/b2/async-func-expr-named-forbidden-ext-indirect-access-prop-caller.js
index 71d070fe3b..17509fdab0 100644
--- a/test/language/expressions/async-function/forbidden-ext/b2/async-func-expr-named-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/expressions/async-function/forbidden-ext/b2/async-func-expr-named-forbidden-ext-indirect-access-prop-caller.js
@@ -4,34 +4,61 @@
 /*---
 description: Forbidden extension, o.caller (async function named expression)
 esid: sec-async-definitions
-features: [async-functions]
+features: [arrow-function, async-functions]
 flags: [generated, noStrict, async]
 info: |
     AsyncFunctionExpression :
       async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody }
 
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 
 var callCount = 0;
-var f = async function f() {
+var f;
+f = async function f() {
   "use strict";
-  inner().toString();
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && false) {
+    Object.defineProperty(inner, "caller", {});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && false) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
   callCount++;
 }
 
 f()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/async-function/forbidden-ext/b2/async-func-expr-nameless-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/expressions/async-function/forbidden-ext/b2/async-func-expr-nameless-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..956c6a1069
--- /dev/null
+++ b/test/language/expressions/async-function/forbidden-ext/b2/async-func-expr-nameless-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/async-func-expr-nameless.template
+/*---
+description: Forbidden extension, o.caller (async function nameless expression)
+esid: sec-async-definitions
+features: [arrow-function, async-functions]
+flags: [generated, noStrict, async]
+info: |
+    AsyncFunctionExpression :
+      async function ( FormalParameters ) { AsyncFunctionBody }
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+
+var callCount = 0;
+var f;
+f = async function() {
+  "use strict";
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && true) {
+    Object.defineProperty(inner, "caller", {get(){return 1}});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && true) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+  callCount++;
+}
+
+f()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/async-function/forbidden-ext/b2/async-func-expr-nameless-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/expressions/async-function/forbidden-ext/b2/async-func-expr-nameless-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..fc46769604
--- /dev/null
+++ b/test/language/expressions/async-function/forbidden-ext/b2/async-func-expr-nameless-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/async-func-expr-nameless.template
+/*---
+description: Forbidden extension, o.caller (async function nameless expression)
+esid: sec-async-definitions
+features: [arrow-function, async-functions]
+flags: [generated, noStrict, async]
+info: |
+    AsyncFunctionExpression :
+      async function ( FormalParameters ) { AsyncFunctionBody }
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+
+var callCount = 0;
+var f;
+f = async function() {
+  "use strict";
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && true) {
+    Object.defineProperty(inner, "caller", {value: 1});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && true) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+  callCount++;
+}
+
+f()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/async-function/forbidden-ext/b2/async-func-expr-nameless-forbidden-ext-indirect-access-prop-caller.js b/test/language/expressions/async-function/forbidden-ext/b2/async-func-expr-nameless-forbidden-ext-indirect-access-prop-caller.js
index bad9a0f406..ba8d764bb2 100644
--- a/test/language/expressions/async-function/forbidden-ext/b2/async-func-expr-nameless-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/expressions/async-function/forbidden-ext/b2/async-func-expr-nameless-forbidden-ext-indirect-access-prop-caller.js
@@ -4,34 +4,61 @@
 /*---
 description: Forbidden extension, o.caller (async function nameless expression)
 esid: sec-async-definitions
-features: [async-functions]
+features: [arrow-function, async-functions]
 flags: [generated, noStrict, async]
 info: |
     AsyncFunctionExpression :
       async function ( FormalParameters ) { AsyncFunctionBody }
 
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 
 var callCount = 0;
-var f = async function() {
+var f;
+f = async function() {
   "use strict";
-  inner().toString();
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && false) {
+    Object.defineProperty(inner, "caller", {});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && false) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
   callCount++;
 }
 
 f()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/forbidden-ext/b1/async-gen-func-expr-forbidden-ext-direct-access-prop-arguments.js b/test/language/expressions/async-generator/forbidden-ext/b1/async-gen-func-expr-forbidden-ext-direct-access-prop-arguments.js
index ccf10b3a55..e80036b74e 100644
--- a/test/language/expressions/async-generator/forbidden-ext/b1/async-gen-func-expr-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/expressions/async-generator/forbidden-ext/b1/async-gen-func-expr-forbidden-ext-direct-access-prop-arguments.js
@@ -4,14 +4,23 @@
 /*---
 description: Forbidden extension, f.arguments (async generator function expression)
 esid: sec-asyncgenerator-definitions-evaluation
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration]
 flags: [generated, noStrict, async]
 info: |
     AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
         AsyncGeneratorBody }
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
@@ -19,15 +28,11 @@ info: |
 var callCount = 0;
 var f;
 f = async function*() {
-  f.arguments;
+  assert.sameValue(f.hasOwnProperty("arguments"), false);
   callCount++;
 };
 
 f().next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/forbidden-ext/b1/async-gen-func-expr-forbidden-ext-direct-access-prop-caller.js b/test/language/expressions/async-generator/forbidden-ext/b1/async-gen-func-expr-forbidden-ext-direct-access-prop-caller.js
index 071d311967..d843231a37 100644
--- a/test/language/expressions/async-generator/forbidden-ext/b1/async-gen-func-expr-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/expressions/async-generator/forbidden-ext/b1/async-gen-func-expr-forbidden-ext-direct-access-prop-caller.js
@@ -4,14 +4,23 @@
 /*---
 description: Forbidden extension, o.caller (async generator function expression)
 esid: sec-asyncgenerator-definitions-evaluation
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration]
 flags: [generated, noStrict, async]
 info: |
     AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
         AsyncGeneratorBody }
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
@@ -19,15 +28,11 @@ info: |
 var callCount = 0;
 var f;
 f = async function*() {
-  f.caller;
+  assert.sameValue(f.hasOwnProperty("caller"), false);
   callCount++;
 };
 
 f().next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/forbidden-ext/b1/async-gen-named-func-expr-forbidden-ext-direct-access-prop-arguments.js b/test/language/expressions/async-generator/forbidden-ext/b1/async-gen-named-func-expr-forbidden-ext-direct-access-prop-arguments.js
index 210e5a984a..04f150c963 100644
--- a/test/language/expressions/async-generator/forbidden-ext/b1/async-gen-named-func-expr-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/expressions/async-generator/forbidden-ext/b1/async-gen-named-func-expr-forbidden-ext-direct-access-prop-arguments.js
@@ -4,14 +4,23 @@
 /*---
 description: Forbidden extension, f.arguments (async generator named function expression)
 esid: sec-asyncgenerator-definitions-evaluation
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration]
 flags: [generated, noStrict, async]
 info: |
     AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
         ( FormalParameters ) { AsyncGeneratorBody }
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
@@ -19,15 +28,11 @@ info: |
 var callCount = 0;
 var f;
 f = async function* g() {
-  f.arguments;
+  assert.sameValue(f.hasOwnProperty("arguments"), false);
   callCount++;
 };
 
 f().next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/forbidden-ext/b1/async-gen-named-func-expr-forbidden-ext-direct-access-prop-caller.js b/test/language/expressions/async-generator/forbidden-ext/b1/async-gen-named-func-expr-forbidden-ext-direct-access-prop-caller.js
index 928c49846d..1a3f1f52d5 100644
--- a/test/language/expressions/async-generator/forbidden-ext/b1/async-gen-named-func-expr-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/expressions/async-generator/forbidden-ext/b1/async-gen-named-func-expr-forbidden-ext-direct-access-prop-caller.js
@@ -4,14 +4,23 @@
 /*---
 description: Forbidden extension, o.caller (async generator named function expression)
 esid: sec-asyncgenerator-definitions-evaluation
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration]
 flags: [generated, noStrict, async]
 info: |
     AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
         ( FormalParameters ) { AsyncGeneratorBody }
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
@@ -19,15 +28,11 @@ info: |
 var callCount = 0;
 var f;
 f = async function* g() {
-  f.caller;
+  assert.sameValue(f.hasOwnProperty("caller"), false);
   callCount++;
 };
 
 f().next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/forbidden-ext/b2/async-gen-func-expr-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/expressions/async-generator/forbidden-ext/b2/async-gen-func-expr-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..81bf2c576f
--- /dev/null
+++ b/test/language/expressions/async-generator/forbidden-ext/b2/async-gen-func-expr-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/async-gen-func-expr.template
+/*---
+description: Forbidden extension, o.caller (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [arrow-function, async-functions, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+    AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+        AsyncGeneratorBody }
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+
+var callCount = 0;
+var f;
+f = async function*() {
+  "use strict";
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && true) {
+    Object.defineProperty(inner, "caller", {get(){return 1}});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && true) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+  callCount++;
+};
+
+f().next()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/forbidden-ext/b2/async-gen-func-expr-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/expressions/async-generator/forbidden-ext/b2/async-gen-func-expr-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..b12901310d
--- /dev/null
+++ b/test/language/expressions/async-generator/forbidden-ext/b2/async-gen-func-expr-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/async-gen-func-expr.template
+/*---
+description: Forbidden extension, o.caller (async generator function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [arrow-function, async-functions, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+    AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
+        AsyncGeneratorBody }
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+
+var callCount = 0;
+var f;
+f = async function*() {
+  "use strict";
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && true) {
+    Object.defineProperty(inner, "caller", {value: 1});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && true) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+  callCount++;
+};
+
+f().next()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/forbidden-ext/b2/async-gen-func-expr-forbidden-ext-indirect-access-prop-caller.js b/test/language/expressions/async-generator/forbidden-ext/b2/async-gen-func-expr-forbidden-ext-indirect-access-prop-caller.js
index 1c7bbd005f..fd5f02cfb2 100644
--- a/test/language/expressions/async-generator/forbidden-ext/b2/async-gen-func-expr-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/expressions/async-generator/forbidden-ext/b2/async-gen-func-expr-forbidden-ext-indirect-access-prop-caller.js
@@ -4,19 +4,25 @@
 /*---
 description: Forbidden extension, o.caller (async generator function expression)
 esid: sec-asyncgenerator-definitions-evaluation
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration]
 flags: [generated, noStrict, async]
 info: |
     AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
         AsyncGeneratorBody }
 
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 
@@ -24,15 +30,35 @@ var callCount = 0;
 var f;
 f = async function*() {
   "use strict";
-  inner().toString();
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && false) {
+    Object.defineProperty(inner, "caller", {});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && false) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
   callCount++;
 };
 
 f().next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/forbidden-ext/b2/async-gen-named-func-expr-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/expressions/async-generator/forbidden-ext/b2/async-gen-named-func-expr-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..a63c261155
--- /dev/null
+++ b/test/language/expressions/async-generator/forbidden-ext/b2/async-gen-named-func-expr-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/async-gen-named-func-expr.template
+/*---
+description: Forbidden extension, o.caller (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [arrow-function, async-functions, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+    AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+        ( FormalParameters ) { AsyncGeneratorBody }
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+
+var callCount = 0;
+var f;
+f = async function* g() {
+  "use strict";
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && true) {
+    Object.defineProperty(inner, "caller", {get(){return 1}});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && true) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+  callCount++;
+};
+
+f().next()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/forbidden-ext/b2/async-gen-named-func-expr-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/expressions/async-generator/forbidden-ext/b2/async-gen-named-func-expr-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..61ff35ad5b
--- /dev/null
+++ b/test/language/expressions/async-generator/forbidden-ext/b2/async-gen-named-func-expr-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/async-gen-named-func-expr.template
+/*---
+description: Forbidden extension, o.caller (async generator named function expression)
+esid: sec-asyncgenerator-definitions-evaluation
+features: [arrow-function, async-functions, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+    AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
+        ( FormalParameters ) { AsyncGeneratorBody }
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+
+var callCount = 0;
+var f;
+f = async function* g() {
+  "use strict";
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && true) {
+    Object.defineProperty(inner, "caller", {value: 1});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && true) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+  callCount++;
+};
+
+f().next()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/async-generator/forbidden-ext/b2/async-gen-named-func-expr-forbidden-ext-indirect-access-prop-caller.js b/test/language/expressions/async-generator/forbidden-ext/b2/async-gen-named-func-expr-forbidden-ext-indirect-access-prop-caller.js
index e4fc69a29b..3971ce8583 100644
--- a/test/language/expressions/async-generator/forbidden-ext/b2/async-gen-named-func-expr-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/expressions/async-generator/forbidden-ext/b2/async-gen-named-func-expr-forbidden-ext-indirect-access-prop-caller.js
@@ -4,19 +4,25 @@
 /*---
 description: Forbidden extension, o.caller (async generator named function expression)
 esid: sec-asyncgenerator-definitions-evaluation
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration]
 flags: [generated, noStrict, async]
 info: |
     AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
         ( FormalParameters ) { AsyncGeneratorBody }
 
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 
@@ -24,15 +30,35 @@ var callCount = 0;
 var f;
 f = async function* g() {
   "use strict";
-  inner().toString();
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && false) {
+    Object.defineProperty(inner, "caller", {});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && false) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
   callCount++;
 };
 
 f().next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/async-gen-method-static/forbidden-ext/b1/cls-expr-async-gen-meth-static-forbidden-ext-direct-access-prop-arguments.js b/test/language/expressions/class/async-gen-method-static/forbidden-ext/b1/cls-expr-async-gen-meth-static-forbidden-ext-direct-access-prop-arguments.js
index 1383564ea9..2f634579ba 100644
--- a/test/language/expressions/class/async-gen-method-static/forbidden-ext/b1/cls-expr-async-gen-meth-static-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/expressions/class/async-gen-method-static/forbidden-ext/b1/cls-expr-async-gen-meth-static-forbidden-ext-direct-access-prop-arguments.js
@@ -4,29 +4,34 @@
 /*---
 description: Forbidden extension, f.arguments (static class expression async generator method)
 esid: sec-class-definitions-runtime-semantics-evaluation
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration, class]
 flags: [generated, noStrict, async]
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 var C = class {
   static async *method() {
-    this.method.arguments;
+    assert.sameValue(this.method.hasOwnProperty("arguments"), false);
     callCount++;
   }
 };
 
 C.method().next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/async-gen-method-static/forbidden-ext/b1/cls-expr-async-gen-meth-static-forbidden-ext-direct-access-prop-caller.js b/test/language/expressions/class/async-gen-method-static/forbidden-ext/b1/cls-expr-async-gen-meth-static-forbidden-ext-direct-access-prop-caller.js
index 001fdc4d00..c0ff741536 100644
--- a/test/language/expressions/class/async-gen-method-static/forbidden-ext/b1/cls-expr-async-gen-meth-static-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/expressions/class/async-gen-method-static/forbidden-ext/b1/cls-expr-async-gen-meth-static-forbidden-ext-direct-access-prop-caller.js
@@ -4,29 +4,34 @@
 /*---
 description: Forbidden extension, o.caller (static class expression async generator method)
 esid: sec-class-definitions-runtime-semantics-evaluation
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration, class]
 flags: [generated, noStrict, async]
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 var C = class {
   static async *method() {
-    this.method.caller;
+    assert.sameValue(this.method.hasOwnProperty("caller"), false);
     callCount++;
   }
 };
 
 C.method().next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/async-gen-method-static/forbidden-ext/b2/cls-expr-async-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/expressions/class/async-gen-method-static/forbidden-ext/b2/cls-expr-async-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..a31c1a9901
--- /dev/null
+++ b/test/language/expressions/class/async-gen-method-static/forbidden-ext/b2/cls-expr-async-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-expr-async-gen-meth-static.template
+/*---
+description: Forbidden extension, o.caller (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [arrow-function, async-functions, async-iteration, class]
+flags: [generated, noStrict, async]
+info: |
+    ClassExpression : class BindingIdentifieropt ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+var C = class {
+  static async *method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {get(){return 1}});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+};
+
+C.method().next()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/async-gen-method-static/forbidden-ext/b2/cls-expr-async-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/expressions/class/async-gen-method-static/forbidden-ext/b2/cls-expr-async-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..6c7fbf2196
--- /dev/null
+++ b/test/language/expressions/class/async-gen-method-static/forbidden-ext/b2/cls-expr-async-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-expr-async-gen-meth-static.template
+/*---
+description: Forbidden extension, o.caller (static class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [arrow-function, async-functions, async-iteration, class]
+flags: [generated, noStrict, async]
+info: |
+    ClassExpression : class BindingIdentifieropt ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+var C = class {
+  static async *method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {value: 1});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+};
+
+C.method().next()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/async-gen-method-static/forbidden-ext/b2/cls-expr-async-gen-meth-static-forbidden-ext-indirect-access-prop-caller.js b/test/language/expressions/class/async-gen-method-static/forbidden-ext/b2/cls-expr-async-gen-meth-static-forbidden-ext-indirect-access-prop-caller.js
index 4cda39e0b0..402e120f3a 100644
--- a/test/language/expressions/class/async-gen-method-static/forbidden-ext/b2/cls-expr-async-gen-meth-static-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/expressions/class/async-gen-method-static/forbidden-ext/b2/cls-expr-async-gen-meth-static-forbidden-ext-indirect-access-prop-caller.js
@@ -4,34 +4,60 @@
 /*---
 description: Forbidden extension, o.caller (static class expression async generator method)
 esid: sec-class-definitions-runtime-semantics-evaluation
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration, class]
 flags: [generated, noStrict, async]
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
 
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 var callCount = 0;
 var C = class {
   static async *method() {
     /* implicit strict */
-    inner().toString();
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && false) {
+      Object.defineProperty(inner, "caller", {});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && false) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
     callCount++;
   }
 };
 
 C.method().next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/async-gen-method/forbidden-ext/b1/cls-expr-async-gen-meth-forbidden-ext-direct-access-prop-arguments.js b/test/language/expressions/class/async-gen-method/forbidden-ext/b1/cls-expr-async-gen-meth-forbidden-ext-direct-access-prop-arguments.js
index d1aade87fa..d66f1b031c 100644
--- a/test/language/expressions/class/async-gen-method/forbidden-ext/b1/cls-expr-async-gen-meth-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/expressions/class/async-gen-method/forbidden-ext/b1/cls-expr-async-gen-meth-forbidden-ext-direct-access-prop-arguments.js
@@ -4,29 +4,34 @@
 /*---
 description: Forbidden extension, f.arguments (class expression async generator method)
 esid: sec-class-definitions-runtime-semantics-evaluation
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration, class]
 flags: [generated, noStrict, async]
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 var C = class {
   async *method() {
-    this.method.arguments;
+    assert.sameValue(this.method.hasOwnProperty("arguments"), false);
     callCount++;
   }
 };
 
 C.prototype.method().next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/async-gen-method/forbidden-ext/b1/cls-expr-async-gen-meth-forbidden-ext-direct-access-prop-caller.js b/test/language/expressions/class/async-gen-method/forbidden-ext/b1/cls-expr-async-gen-meth-forbidden-ext-direct-access-prop-caller.js
index 7200d5f594..d4f5340f5f 100644
--- a/test/language/expressions/class/async-gen-method/forbidden-ext/b1/cls-expr-async-gen-meth-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/expressions/class/async-gen-method/forbidden-ext/b1/cls-expr-async-gen-meth-forbidden-ext-direct-access-prop-caller.js
@@ -4,29 +4,34 @@
 /*---
 description: Forbidden extension, o.caller (class expression async generator method)
 esid: sec-class-definitions-runtime-semantics-evaluation
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration, class]
 flags: [generated, noStrict, async]
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 var C = class {
   async *method() {
-    this.method.caller;
+    assert.sameValue(this.method.hasOwnProperty("caller"), false);
     callCount++;
   }
 };
 
 C.prototype.method().next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/async-gen-method/forbidden-ext/b2/cls-expr-async-gen-meth-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/expressions/class/async-gen-method/forbidden-ext/b2/cls-expr-async-gen-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..4a79b81e9c
--- /dev/null
+++ b/test/language/expressions/class/async-gen-method/forbidden-ext/b2/cls-expr-async-gen-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-expr-async-gen-meth.template
+/*---
+description: Forbidden extension, o.caller (class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [arrow-function, async-functions, async-iteration, class]
+flags: [generated, noStrict, async]
+info: |
+    ClassExpression : class BindingIdentifieropt ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+var C = class {
+  async *method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {get(){return 1}});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+};
+
+C.prototype.method().next()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/async-gen-method/forbidden-ext/b2/cls-expr-async-gen-meth-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/expressions/class/async-gen-method/forbidden-ext/b2/cls-expr-async-gen-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..e4356b1fa1
--- /dev/null
+++ b/test/language/expressions/class/async-gen-method/forbidden-ext/b2/cls-expr-async-gen-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-expr-async-gen-meth.template
+/*---
+description: Forbidden extension, o.caller (class expression async generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [arrow-function, async-functions, async-iteration, class]
+flags: [generated, noStrict, async]
+info: |
+    ClassExpression : class BindingIdentifieropt ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+var C = class {
+  async *method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {value: 1});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+};
+
+C.prototype.method().next()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/async-gen-method/forbidden-ext/b2/cls-expr-async-gen-meth-forbidden-ext-indirect-access-prop-caller.js b/test/language/expressions/class/async-gen-method/forbidden-ext/b2/cls-expr-async-gen-meth-forbidden-ext-indirect-access-prop-caller.js
index 572c68a116..a9fbae5e33 100644
--- a/test/language/expressions/class/async-gen-method/forbidden-ext/b2/cls-expr-async-gen-meth-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/expressions/class/async-gen-method/forbidden-ext/b2/cls-expr-async-gen-meth-forbidden-ext-indirect-access-prop-caller.js
@@ -4,34 +4,60 @@
 /*---
 description: Forbidden extension, o.caller (class expression async generator method)
 esid: sec-class-definitions-runtime-semantics-evaluation
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration, class]
 flags: [generated, noStrict, async]
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
 
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 var callCount = 0;
 var C = class {
   async *method() {
     /* implicit strict */
-    inner().toString();
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && false) {
+      Object.defineProperty(inner, "caller", {});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && false) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
     callCount++;
   }
 };
 
 C.prototype.method().next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/async-method-static/forbidden-ext/b1/cls-expr-async-meth-static-forbidden-ext-direct-access-prop-arguments.js b/test/language/expressions/class/async-method-static/forbidden-ext/b1/cls-expr-async-meth-static-forbidden-ext-direct-access-prop-arguments.js
index 917d024fa5..528ba8fb99 100644
--- a/test/language/expressions/class/async-method-static/forbidden-ext/b1/cls-expr-async-meth-static-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/expressions/class/async-method-static/forbidden-ext/b1/cls-expr-async-meth-static-forbidden-ext-direct-access-prop-arguments.js
@@ -4,13 +4,22 @@
 /*---
 description: Forbidden extension, f.arguments (static class expression async method)
 esid: sec-class-definitions-runtime-semantics-evaluation
-features: [async-functions]
+features: [arrow-function, async-functions, class]
 flags: [generated, noStrict, async]
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
@@ -19,16 +28,12 @@ var callCount = 0;
 
 var C = class {
   static async method() {
-    this.method.arguments;
+    assert.sameValue(this.method.hasOwnProperty("arguments"), false);
     callCount++;
   }
 };
 
 C.method()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/async-method-static/forbidden-ext/b1/cls-expr-async-meth-static-forbidden-ext-direct-access-prop-caller.js b/test/language/expressions/class/async-method-static/forbidden-ext/b1/cls-expr-async-meth-static-forbidden-ext-direct-access-prop-caller.js
index 18fd49d62b..a4821f0a76 100644
--- a/test/language/expressions/class/async-method-static/forbidden-ext/b1/cls-expr-async-meth-static-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/expressions/class/async-method-static/forbidden-ext/b1/cls-expr-async-meth-static-forbidden-ext-direct-access-prop-caller.js
@@ -4,13 +4,22 @@
 /*---
 description: Forbidden extension, o.caller (static class expression async method)
 esid: sec-class-definitions-runtime-semantics-evaluation
-features: [async-functions]
+features: [arrow-function, async-functions, class]
 flags: [generated, noStrict, async]
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
@@ -19,16 +28,12 @@ var callCount = 0;
 
 var C = class {
   static async method() {
-    this.method.caller;
+    assert.sameValue(this.method.hasOwnProperty("caller"), false);
     callCount++;
   }
 };
 
 C.method()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/async-method-static/forbidden-ext/b2/cls-expr-async-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/expressions/class/async-method-static/forbidden-ext/b2/cls-expr-async-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..b0c6a3b538
--- /dev/null
+++ b/test/language/expressions/class/async-method-static/forbidden-ext/b2/cls-expr-async-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-expr-async-meth-static.template
+/*---
+description: Forbidden extension, o.caller (static class expression async method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [arrow-function, async-functions, class]
+flags: [generated, noStrict, async]
+info: |
+    ClassExpression : class BindingIdentifieropt ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+
+var callCount = 0;
+
+var C = class {
+  static async method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {get(){return 1}});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+};
+
+C.method()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/async-method-static/forbidden-ext/b2/cls-expr-async-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/expressions/class/async-method-static/forbidden-ext/b2/cls-expr-async-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..626fd8009e
--- /dev/null
+++ b/test/language/expressions/class/async-method-static/forbidden-ext/b2/cls-expr-async-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-expr-async-meth-static.template
+/*---
+description: Forbidden extension, o.caller (static class expression async method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [arrow-function, async-functions, class]
+flags: [generated, noStrict, async]
+info: |
+    ClassExpression : class BindingIdentifieropt ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+
+var callCount = 0;
+
+var C = class {
+  static async method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {value: 1});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+};
+
+C.method()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/async-method-static/forbidden-ext/b2/cls-expr-async-meth-static-forbidden-ext-indirect-access-prop-caller.js b/test/language/expressions/class/async-method-static/forbidden-ext/b2/cls-expr-async-meth-static-forbidden-ext-indirect-access-prop-caller.js
index 8e1c880ff4..d629f2c719 100644
--- a/test/language/expressions/class/async-method-static/forbidden-ext/b2/cls-expr-async-meth-static-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/expressions/class/async-method-static/forbidden-ext/b2/cls-expr-async-meth-static-forbidden-ext-indirect-access-prop-caller.js
@@ -4,18 +4,24 @@
 /*---
 description: Forbidden extension, o.caller (static class expression async method)
 esid: sec-class-definitions-runtime-semantics-evaluation
-features: [async-functions]
+features: [arrow-function, async-functions, class]
 flags: [generated, noStrict, async]
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
 
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 
@@ -24,16 +30,36 @@ var callCount = 0;
 var C = class {
   static async method() {
     /* implicit strict */
-    inner().toString();
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && false) {
+      Object.defineProperty(inner, "caller", {});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && false) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
     callCount++;
   }
 };
 
 C.method()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/async-method/forbidden-ext/b1/cls-expr-async-meth-forbidden-ext-direct-access-prop-arguments.js b/test/language/expressions/class/async-method/forbidden-ext/b1/cls-expr-async-meth-forbidden-ext-direct-access-prop-arguments.js
index 55b2fc7534..b94c4b0190 100644
--- a/test/language/expressions/class/async-method/forbidden-ext/b1/cls-expr-async-meth-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/expressions/class/async-method/forbidden-ext/b1/cls-expr-async-meth-forbidden-ext-direct-access-prop-arguments.js
@@ -4,13 +4,22 @@
 /*---
 description: Forbidden extension, f.arguments (class expression async method)
 esid: sec-class-definitions-runtime-semantics-evaluation
-features: [async-functions]
+features: [arrow-function, async-functions, class]
 flags: [generated, noStrict, async]
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
@@ -18,16 +27,12 @@ info: |
 var callCount = 0;
 var C = class {
   async method() {
-    this.method.arguments;
+    assert.sameValue(this.method.hasOwnProperty("arguments"), false);
     callCount++;
   }
 };
 
 C.prototype.method()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/async-method/forbidden-ext/b1/cls-expr-async-meth-forbidden-ext-direct-access-prop-caller.js b/test/language/expressions/class/async-method/forbidden-ext/b1/cls-expr-async-meth-forbidden-ext-direct-access-prop-caller.js
index 0eb78693b2..5ef11ec4f4 100644
--- a/test/language/expressions/class/async-method/forbidden-ext/b1/cls-expr-async-meth-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/expressions/class/async-method/forbidden-ext/b1/cls-expr-async-meth-forbidden-ext-direct-access-prop-caller.js
@@ -4,13 +4,22 @@
 /*---
 description: Forbidden extension, o.caller (class expression async method)
 esid: sec-class-definitions-runtime-semantics-evaluation
-features: [async-functions]
+features: [arrow-function, async-functions, class]
 flags: [generated, noStrict, async]
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
@@ -18,16 +27,12 @@ info: |
 var callCount = 0;
 var C = class {
   async method() {
-    this.method.caller;
+    assert.sameValue(this.method.hasOwnProperty("caller"), false);
     callCount++;
   }
 };
 
 C.prototype.method()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/async-method/forbidden-ext/b2/cls-expr-async-meth-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/expressions/class/async-method/forbidden-ext/b2/cls-expr-async-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..5b292d5c60
--- /dev/null
+++ b/test/language/expressions/class/async-method/forbidden-ext/b2/cls-expr-async-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-expr-async-meth.template
+/*---
+description: Forbidden extension, o.caller (class expression async method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [arrow-function, async-functions, class]
+flags: [generated, noStrict, async]
+info: |
+    ClassExpression : class BindingIdentifieropt ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+
+var callCount = 0;
+var C = class {
+  async method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {get(){return 1}});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+};
+
+C.prototype.method()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/async-method/forbidden-ext/b2/cls-expr-async-meth-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/expressions/class/async-method/forbidden-ext/b2/cls-expr-async-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..b9bdcabdb1
--- /dev/null
+++ b/test/language/expressions/class/async-method/forbidden-ext/b2/cls-expr-async-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-expr-async-meth.template
+/*---
+description: Forbidden extension, o.caller (class expression async method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [arrow-function, async-functions, class]
+flags: [generated, noStrict, async]
+info: |
+    ClassExpression : class BindingIdentifieropt ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+
+var callCount = 0;
+var C = class {
+  async method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {value: 1});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+};
+
+C.prototype.method()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/async-method/forbidden-ext/b2/cls-expr-async-meth-forbidden-ext-indirect-access-prop-caller.js b/test/language/expressions/class/async-method/forbidden-ext/b2/cls-expr-async-meth-forbidden-ext-indirect-access-prop-caller.js
index 412b5fbba3..6475d0f20f 100644
--- a/test/language/expressions/class/async-method/forbidden-ext/b2/cls-expr-async-meth-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/expressions/class/async-method/forbidden-ext/b2/cls-expr-async-meth-forbidden-ext-indirect-access-prop-caller.js
@@ -4,18 +4,24 @@
 /*---
 description: Forbidden extension, o.caller (class expression async method)
 esid: sec-class-definitions-runtime-semantics-evaluation
-features: [async-functions]
+features: [arrow-function, async-functions, class]
 flags: [generated, noStrict, async]
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
 
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 
@@ -23,16 +29,36 @@ var callCount = 0;
 var C = class {
   async method() {
     /* implicit strict */
-    inner().toString();
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && false) {
+      Object.defineProperty(inner, "caller", {});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && false) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
     callCount++;
   }
 };
 
 C.prototype.method()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/class/gen-method-static/forbidden-ext/b1/cls-expr-gen-meth-static-forbidden-ext-direct-access-prop-arguments.js b/test/language/expressions/class/gen-method-static/forbidden-ext/b1/cls-expr-gen-meth-static-forbidden-ext-direct-access-prop-arguments.js
index ef2d6c5aab..dc59fd5cf8 100644
--- a/test/language/expressions/class/gen-method-static/forbidden-ext/b1/cls-expr-gen-meth-static-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/expressions/class/gen-method-static/forbidden-ext/b1/cls-expr-gen-meth-static-forbidden-ext-direct-access-prop-arguments.js
@@ -4,25 +4,32 @@
 /*---
 description: Forbidden extension, f.arguments (static class expression generator method)
 esid: sec-class-definitions-runtime-semantics-evaluation
-features: [generators]
+features: [class, generators]
 flags: [generated, noStrict]
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 var C = class {
   static *method() {
-    this.method.arguments;
+    assert.sameValue(this.method.hasOwnProperty("arguments"), false);
     callCount++;
   }
 };
 
-assert.throws(TypeError, function() {
-  C.method().next();
-});
-assert.sameValue(callCount, 0, 'method body not evaluated');
+C.method().next();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/expressions/class/gen-method-static/forbidden-ext/b1/cls-expr-gen-meth-static-forbidden-ext-direct-access-prop-caller.js b/test/language/expressions/class/gen-method-static/forbidden-ext/b1/cls-expr-gen-meth-static-forbidden-ext-direct-access-prop-caller.js
index 83bcd52a22..a1bd6d181c 100644
--- a/test/language/expressions/class/gen-method-static/forbidden-ext/b1/cls-expr-gen-meth-static-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/expressions/class/gen-method-static/forbidden-ext/b1/cls-expr-gen-meth-static-forbidden-ext-direct-access-prop-caller.js
@@ -4,25 +4,32 @@
 /*---
 description: Forbidden extension, o.caller (static class expression generator method)
 esid: sec-class-definitions-runtime-semantics-evaluation
-features: [generators]
+features: [class, generators]
 flags: [generated, noStrict]
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 var C = class {
   static *method() {
-    this.method.caller;
+    assert.sameValue(this.method.hasOwnProperty("caller"), false);
     callCount++;
   }
 };
 
-assert.throws(TypeError, function() {
-  C.method().next();
-});
-assert.sameValue(callCount, 0, 'method body not evaluated');
+C.method().next();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/expressions/class/gen-method-static/forbidden-ext/b2/cls-expr-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/expressions/class/gen-method-static/forbidden-ext/b2/cls-expr-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..ea3e6d357e
--- /dev/null
+++ b/test/language/expressions/class/gen-method-static/forbidden-ext/b2/cls-expr-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,61 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-expr-gen-meth-static.template
+/*---
+description: Forbidden extension, o.caller (static class expression generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [class, generators]
+flags: [generated, noStrict]
+info: |
+    ClassExpression : class BindingIdentifieropt ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+var C = class {
+  static *method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {get(){return 1}});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+};
+
+C.method().next();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/expressions/class/gen-method-static/forbidden-ext/b2/cls-expr-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/expressions/class/gen-method-static/forbidden-ext/b2/cls-expr-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..155ac696b8
--- /dev/null
+++ b/test/language/expressions/class/gen-method-static/forbidden-ext/b2/cls-expr-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,61 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-expr-gen-meth-static.template
+/*---
+description: Forbidden extension, o.caller (static class expression generator method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [class, generators]
+flags: [generated, noStrict]
+info: |
+    ClassExpression : class BindingIdentifieropt ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+var C = class {
+  static *method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {value: 1});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+};
+
+C.method().next();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/expressions/class/gen-method-static/forbidden-ext/b2/cls-expr-gen-meth-static-forbidden-ext-indirect-access-prop-caller.js b/test/language/expressions/class/gen-method-static/forbidden-ext/b2/cls-expr-gen-meth-static-forbidden-ext-indirect-access-prop-caller.js
index a8177c2fcc..a77e86e798 100644
--- a/test/language/expressions/class/gen-method-static/forbidden-ext/b2/cls-expr-gen-meth-static-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/expressions/class/gen-method-static/forbidden-ext/b2/cls-expr-gen-meth-static-forbidden-ext-indirect-access-prop-caller.js
@@ -4,30 +4,58 @@
 /*---
 description: Forbidden extension, o.caller (static class expression generator method)
 esid: sec-class-definitions-runtime-semantics-evaluation
-features: [generators]
+features: [class, generators]
 flags: [generated, noStrict]
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
 
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 var callCount = 0;
 var C = class {
   static *method() {
     /* implicit strict */
-    inner().toString();
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && false) {
+      Object.defineProperty(inner, "caller", {});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && false) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
     callCount++;
   }
 };
 
-assert.throws(TypeError, function() {
-  C.method().next();
-});
-assert.sameValue(callCount, 0, 'method body not evaluated');
+C.method().next();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/expressions/class/gen-method/forbidden-ext/b1/cls-expr-gen-meth-forbidden-ext-direct-access-prop-arguments.js b/test/language/expressions/class/gen-method/forbidden-ext/b1/cls-expr-gen-meth-forbidden-ext-direct-access-prop-arguments.js
index abc4dfa71e..59ea9ca634 100644
--- a/test/language/expressions/class/gen-method/forbidden-ext/b1/cls-expr-gen-meth-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/expressions/class/gen-method/forbidden-ext/b1/cls-expr-gen-meth-forbidden-ext-direct-access-prop-arguments.js
@@ -4,25 +4,32 @@
 /*---
 description: Forbidden extension, f.arguments (class expression method)
 esid: sec-class-definitions-runtime-semantics-evaluation
-features: [generators]
+features: [class, generators]
 flags: [generated, noStrict]
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 var C = class {
   *method() {
-    this.method.arguments;
+    assert.sameValue(this.method.hasOwnProperty("arguments"), false);
     callCount++;
   }
 };
 
-assert.throws(TypeError, function() {
-  C.prototype.method().next();
-});
-assert.sameValue(callCount, 0, 'method body not evaluated');
+C.prototype.method().next();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/expressions/class/gen-method/forbidden-ext/b1/cls-expr-gen-meth-forbidden-ext-direct-access-prop-caller.js b/test/language/expressions/class/gen-method/forbidden-ext/b1/cls-expr-gen-meth-forbidden-ext-direct-access-prop-caller.js
index 2c766b990c..57c7874d3c 100644
--- a/test/language/expressions/class/gen-method/forbidden-ext/b1/cls-expr-gen-meth-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/expressions/class/gen-method/forbidden-ext/b1/cls-expr-gen-meth-forbidden-ext-direct-access-prop-caller.js
@@ -4,25 +4,32 @@
 /*---
 description: Forbidden extension, o.caller (class expression method)
 esid: sec-class-definitions-runtime-semantics-evaluation
-features: [generators]
+features: [class, generators]
 flags: [generated, noStrict]
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 var C = class {
   *method() {
-    this.method.caller;
+    assert.sameValue(this.method.hasOwnProperty("caller"), false);
     callCount++;
   }
 };
 
-assert.throws(TypeError, function() {
-  C.prototype.method().next();
-});
-assert.sameValue(callCount, 0, 'method body not evaluated');
+C.prototype.method().next();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/expressions/class/gen-method/forbidden-ext/b2/cls-expr-gen-meth-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/expressions/class/gen-method/forbidden-ext/b2/cls-expr-gen-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..e26ec579c0
--- /dev/null
+++ b/test/language/expressions/class/gen-method/forbidden-ext/b2/cls-expr-gen-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,62 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-expr-gen-meth.template
+/*---
+description: Forbidden extension, o.caller (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [class, generators]
+flags: [generated, noStrict]
+info: |
+    ClassExpression : class BindingIdentifieropt ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+var C = class {
+  *method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {get(){return 1}});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+
+    callCount++;
+  }
+};
+
+C.prototype.method().next();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/expressions/class/gen-method/forbidden-ext/b2/cls-expr-gen-meth-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/expressions/class/gen-method/forbidden-ext/b2/cls-expr-gen-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..42fb9d7fa6
--- /dev/null
+++ b/test/language/expressions/class/gen-method/forbidden-ext/b2/cls-expr-gen-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,62 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-expr-gen-meth.template
+/*---
+description: Forbidden extension, o.caller (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [class, generators]
+flags: [generated, noStrict]
+info: |
+    ClassExpression : class BindingIdentifieropt ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+var C = class {
+  *method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {value: 1});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+
+    callCount++;
+  }
+};
+
+C.prototype.method().next();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/expressions/class/gen-method/forbidden-ext/b2/cls-expr-gen-meth-forbidden-ext-indirect-access-prop-caller.js b/test/language/expressions/class/gen-method/forbidden-ext/b2/cls-expr-gen-meth-forbidden-ext-indirect-access-prop-caller.js
index 78cbc89b7b..9ab0de4394 100644
--- a/test/language/expressions/class/gen-method/forbidden-ext/b2/cls-expr-gen-meth-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/expressions/class/gen-method/forbidden-ext/b2/cls-expr-gen-meth-forbidden-ext-indirect-access-prop-caller.js
@@ -4,30 +4,59 @@
 /*---
 description: Forbidden extension, o.caller (class expression method)
 esid: sec-class-definitions-runtime-semantics-evaluation
-features: [generators]
+features: [class, generators]
 flags: [generated, noStrict]
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
 
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 var callCount = 0;
 var C = class {
   *method() {
     /* implicit strict */
-    inner().toString();
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && false) {
+      Object.defineProperty(inner, "caller", {});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && false) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+
     callCount++;
   }
 };
 
-assert.throws(TypeError, function() {
-  C.prototype.method().next();
-});
-assert.sameValue(callCount, 0, 'method body not evaluated');
+C.prototype.method().next();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/expressions/class/method-static/forbidden-ext/b1/cls-expr-meth-static-forbidden-ext-direct-access-prop-arguments.js b/test/language/expressions/class/method-static/forbidden-ext/b1/cls-expr-meth-static-forbidden-ext-direct-access-prop-arguments.js
index 938647338d..e34c4f4715 100644
--- a/test/language/expressions/class/method-static/forbidden-ext/b1/cls-expr-meth-static-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/expressions/class/method-static/forbidden-ext/b1/cls-expr-meth-static-forbidden-ext-direct-access-prop-arguments.js
@@ -4,23 +4,32 @@
 /*---
 description: Forbidden extension, f.arguments (static class expression method)
 esid: sec-class-definitions-runtime-semantics-evaluation
+features: [class]
 flags: [generated, noStrict]
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 var C = class {
   static method() {
-    this.method.arguments;
+    assert.sameValue(this.method.hasOwnProperty("arguments"), false);
     callCount++;
   }
 };
 
-assert.throws(TypeError, function() {
-  C.method();
-});
-assert.sameValue(callCount, 0, 'method body not evaluated');
+C.method();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/expressions/class/method-static/forbidden-ext/b1/cls-expr-meth-static-forbidden-ext-direct-access-prop-caller.js b/test/language/expressions/class/method-static/forbidden-ext/b1/cls-expr-meth-static-forbidden-ext-direct-access-prop-caller.js
index 6b2e4a47bc..3ea4ea324b 100644
--- a/test/language/expressions/class/method-static/forbidden-ext/b1/cls-expr-meth-static-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/expressions/class/method-static/forbidden-ext/b1/cls-expr-meth-static-forbidden-ext-direct-access-prop-caller.js
@@ -4,23 +4,32 @@
 /*---
 description: Forbidden extension, o.caller (static class expression method)
 esid: sec-class-definitions-runtime-semantics-evaluation
+features: [class]
 flags: [generated, noStrict]
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 var C = class {
   static method() {
-    this.method.caller;
+    assert.sameValue(this.method.hasOwnProperty("caller"), false);
     callCount++;
   }
 };
 
-assert.throws(TypeError, function() {
-  C.method();
-});
-assert.sameValue(callCount, 0, 'method body not evaluated');
+C.method();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/expressions/class/method-static/forbidden-ext/b2/cls-expr-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/expressions/class/method-static/forbidden-ext/b2/cls-expr-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..2c667910cd
--- /dev/null
+++ b/test/language/expressions/class/method-static/forbidden-ext/b2/cls-expr-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,62 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-expr-meth-static.template
+/*---
+description: Forbidden extension, o.caller (static class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [class]
+flags: [generated, noStrict]
+info: |
+    ClassExpression : class BindingIdentifieropt ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+var C = class {
+  static method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {get(){return 1}});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+
+    callCount++;
+  }
+};
+
+C.method();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/expressions/class/method-static/forbidden-ext/b2/cls-expr-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/expressions/class/method-static/forbidden-ext/b2/cls-expr-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..6487f5fc84
--- /dev/null
+++ b/test/language/expressions/class/method-static/forbidden-ext/b2/cls-expr-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,62 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-expr-meth-static.template
+/*---
+description: Forbidden extension, o.caller (static class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [class]
+flags: [generated, noStrict]
+info: |
+    ClassExpression : class BindingIdentifieropt ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+var C = class {
+  static method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {value: 1});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+
+    callCount++;
+  }
+};
+
+C.method();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/expressions/class/method-static/forbidden-ext/b2/cls-expr-meth-static-forbidden-ext-indirect-access-prop-caller.js b/test/language/expressions/class/method-static/forbidden-ext/b2/cls-expr-meth-static-forbidden-ext-indirect-access-prop-caller.js
index 78c369463f..59d2bc5987 100644
--- a/test/language/expressions/class/method-static/forbidden-ext/b2/cls-expr-meth-static-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/expressions/class/method-static/forbidden-ext/b2/cls-expr-meth-static-forbidden-ext-indirect-access-prop-caller.js
@@ -4,28 +4,59 @@
 /*---
 description: Forbidden extension, o.caller (static class expression method)
 esid: sec-class-definitions-runtime-semantics-evaluation
+features: [class]
 flags: [generated, noStrict]
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 var callCount = 0;
 var C = class {
   static method() {
     /* implicit strict */
-    inner().toString();
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && false) {
+      Object.defineProperty(inner, "caller", {});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && false) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+
     callCount++;
   }
 };
 
-assert.throws(TypeError, function() {
-  C.method();
-});
-assert.sameValue(callCount, 0, 'method body not evaluated');
+C.method();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/expressions/class/method/forbidden-ext/b1/cls-expr-meth-forbidden-ext-direct-access-prop-arguments.js b/test/language/expressions/class/method/forbidden-ext/b1/cls-expr-meth-forbidden-ext-direct-access-prop-arguments.js
index becf8b750e..c92a20b085 100644
--- a/test/language/expressions/class/method/forbidden-ext/b1/cls-expr-meth-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/expressions/class/method/forbidden-ext/b1/cls-expr-meth-forbidden-ext-direct-access-prop-arguments.js
@@ -4,23 +4,32 @@
 /*---
 description: Forbidden extension, f.arguments (class expression method)
 esid: sec-class-definitions-runtime-semantics-evaluation
+features: [class]
 flags: [generated, noStrict]
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 var C = class {
   method() {
-    this.method.arguments;
+    assert.sameValue(this.method.hasOwnProperty("arguments"), false);
     callCount++;
   }
 };
 
-assert.throws(TypeError, function() {
-  C.prototype.method();
-});
-assert.sameValue(callCount, 0, 'method body not evaluated');
+C.prototype.method();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/expressions/class/method/forbidden-ext/b1/cls-expr-meth-forbidden-ext-direct-access-prop-caller.js b/test/language/expressions/class/method/forbidden-ext/b1/cls-expr-meth-forbidden-ext-direct-access-prop-caller.js
index 0394bb2b7f..b2d92d7d71 100644
--- a/test/language/expressions/class/method/forbidden-ext/b1/cls-expr-meth-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/expressions/class/method/forbidden-ext/b1/cls-expr-meth-forbidden-ext-direct-access-prop-caller.js
@@ -4,23 +4,32 @@
 /*---
 description: Forbidden extension, o.caller (class expression method)
 esid: sec-class-definitions-runtime-semantics-evaluation
+features: [class]
 flags: [generated, noStrict]
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 var C = class {
   method() {
-    this.method.caller;
+    assert.sameValue(this.method.hasOwnProperty("caller"), false);
     callCount++;
   }
 };
 
-assert.throws(TypeError, function() {
-  C.prototype.method();
-});
-assert.sameValue(callCount, 0, 'method body not evaluated');
+C.prototype.method();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/expressions/class/method/forbidden-ext/b2/cls-expr-meth-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/expressions/class/method/forbidden-ext/b2/cls-expr-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..e9729e4fa9
--- /dev/null
+++ b/test/language/expressions/class/method/forbidden-ext/b2/cls-expr-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,62 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-expr-meth.template
+/*---
+description: Forbidden extension, o.caller (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [class]
+flags: [generated, noStrict]
+info: |
+    ClassExpression : class BindingIdentifieropt ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+var C = class {
+  method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {get(){return 1}});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+
+    callCount++;
+  }
+};
+
+C.prototype.method();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/expressions/class/method/forbidden-ext/b2/cls-expr-meth-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/expressions/class/method/forbidden-ext/b2/cls-expr-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..ea5b342e76
--- /dev/null
+++ b/test/language/expressions/class/method/forbidden-ext/b2/cls-expr-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,62 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-expr-meth.template
+/*---
+description: Forbidden extension, o.caller (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [class]
+flags: [generated, noStrict]
+info: |
+    ClassExpression : class BindingIdentifieropt ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+var C = class {
+  method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {value: 1});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+
+    callCount++;
+  }
+};
+
+C.prototype.method();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/expressions/class/method/forbidden-ext/b2/cls-expr-meth-forbidden-ext-indirect-access-prop-caller.js b/test/language/expressions/class/method/forbidden-ext/b2/cls-expr-meth-forbidden-ext-indirect-access-prop-caller.js
index 6c2e50d889..d6f37b7b64 100644
--- a/test/language/expressions/class/method/forbidden-ext/b2/cls-expr-meth-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/expressions/class/method/forbidden-ext/b2/cls-expr-meth-forbidden-ext-indirect-access-prop-caller.js
@@ -4,28 +4,59 @@
 /*---
 description: Forbidden extension, o.caller (class expression method)
 esid: sec-class-definitions-runtime-semantics-evaluation
+features: [class]
 flags: [generated, noStrict]
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 var callCount = 0;
 var C = class {
   method() {
     /* implicit strict */
-    inner().toString();
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && false) {
+      Object.defineProperty(inner, "caller", {});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && false) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+
     callCount++;
   }
 };
 
-assert.throws(TypeError, function() {
-  C.prototype.method();
-});
-assert.sameValue(callCount, 0, 'method body not evaluated');
+C.prototype.method();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/expressions/function/forbidden-ext/b1/func-expr-forbidden-ext-direct-access-prop-arguments.js b/test/language/expressions/function/forbidden-ext/b1/func-expr-forbidden-ext-direct-access-prop-arguments.js
deleted file mode 100644
index f3a081443d..0000000000
--- a/test/language/expressions/function/forbidden-ext/b1/func-expr-forbidden-ext-direct-access-prop-arguments.js
+++ /dev/null
@@ -1,26 +0,0 @@
-// This file was procedurally generated from the following sources:
-// - src/function-forms/forbidden-ext-direct-access-prop-arguments.case
-// - src/function-forms/forbidden-extensions/bullet-one/func-expr.template
-/*---
-description: Forbidden extension, f.arguments (function expression)
-esid: sec-function-definitions-runtime-semantics-evaluation
-flags: [generated, noStrict]
-info: |
-    FunctionExpression : function ( FormalParameters ) { FunctionBody }
-
-    In non-strict mode code, a function object created using the FunctionExpression
-    syntactic constructor, is not subject to the following forbidden extension:
-
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
-
----*/
-
-var callCount = 0;
-var f;
-f = function() {
-  f.arguments;
-  callCount++;
-};
-f();
-
-assert.sameValue(callCount, 1, 'function was evaluated');
diff --git a/test/language/expressions/function/forbidden-ext/b1/func-expr-forbidden-ext-direct-access-prop-caller.js b/test/language/expressions/function/forbidden-ext/b1/func-expr-forbidden-ext-direct-access-prop-caller.js
deleted file mode 100644
index c3bcee4157..0000000000
--- a/test/language/expressions/function/forbidden-ext/b1/func-expr-forbidden-ext-direct-access-prop-caller.js
+++ /dev/null
@@ -1,26 +0,0 @@
-// This file was procedurally generated from the following sources:
-// - src/function-forms/forbidden-ext-direct-access-prop-caller.case
-// - src/function-forms/forbidden-extensions/bullet-one/func-expr.template
-/*---
-description: Forbidden extension, o.caller (function expression)
-esid: sec-function-definitions-runtime-semantics-evaluation
-flags: [generated, noStrict]
-info: |
-    FunctionExpression : function ( FormalParameters ) { FunctionBody }
-
-    In non-strict mode code, a function object created using the FunctionExpression
-    syntactic constructor, is not subject to the following forbidden extension:
-
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
-
----*/
-
-var callCount = 0;
-var f;
-f = function() {
-  f.caller;
-  callCount++;
-};
-f();
-
-assert.sameValue(callCount, 1, 'function was evaluated');
diff --git a/test/language/expressions/function/forbidden-ext/b1/func-expr-strict-forbidden-ext-direct-access-prop-arguments.js b/test/language/expressions/function/forbidden-ext/b1/func-expr-strict-forbidden-ext-direct-access-prop-arguments.js
index 1d9332d775..e23a3891a1 100644
--- a/test/language/expressions/function/forbidden-ext/b1/func-expr-strict-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/expressions/function/forbidden-ext/b1/func-expr-strict-forbidden-ext-direct-access-prop-arguments.js
@@ -8,7 +8,16 @@ flags: [generated, noStrict]
 info: |
     FunctionExpression : function ( FormalParameters ) { FunctionBody }
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
@@ -16,10 +25,9 @@ var callCount = 0;
 var f;
 f = function() {
   "use strict";
-  f.arguments;
+  assert.sameValue(f.hasOwnProperty("arguments"), false);
   callCount++;
 };
-assert.throws(TypeError, function() {
-  f();
-});
-assert.sameValue(callCount, 0, 'function body not evaluated');
+
+f();
+assert.sameValue(callCount, 1, 'function body evaluated');
diff --git a/test/language/expressions/function/forbidden-ext/b1/func-expr-strict-forbidden-ext-direct-access-prop-caller.js b/test/language/expressions/function/forbidden-ext/b1/func-expr-strict-forbidden-ext-direct-access-prop-caller.js
index 6f3752226f..ec5465a357 100644
--- a/test/language/expressions/function/forbidden-ext/b1/func-expr-strict-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/expressions/function/forbidden-ext/b1/func-expr-strict-forbidden-ext-direct-access-prop-caller.js
@@ -8,7 +8,16 @@ flags: [generated, noStrict]
 info: |
     FunctionExpression : function ( FormalParameters ) { FunctionBody }
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
@@ -16,10 +25,9 @@ var callCount = 0;
 var f;
 f = function() {
   "use strict";
-  f.caller;
+  assert.sameValue(f.hasOwnProperty("caller"), false);
   callCount++;
 };
-assert.throws(TypeError, function() {
-  f();
-});
-assert.sameValue(callCount, 0, 'function body not evaluated');
+
+f();
+assert.sameValue(callCount, 1, 'function body evaluated');
diff --git a/test/language/expressions/function/forbidden-ext/b2/func-expr-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/expressions/function/forbidden-ext/b2/func-expr-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..ae0b4cd786
--- /dev/null
+++ b/test/language/expressions/function/forbidden-ext/b2/func-expr-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,59 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/func-expr.template
+/*---
+description: Forbidden extension, o.caller (function expression)
+esid: sec-definitions-runtime-semantics-evaluation
+flags: [generated, noStrict]
+info: |
+    FunctionExpression : function ( FormalParameters ) { FunctionBody }
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+var f;
+f = function() {
+  "use strict";
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && true) {
+    Object.defineProperty(inner, "caller", {get(){return 1}});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && true) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+
+  callCount++;
+};
+f();
+assert.sameValue(callCount, 1, 'body evaluated');
diff --git a/test/language/expressions/function/forbidden-ext/b2/func-expr-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/expressions/function/forbidden-ext/b2/func-expr-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..a52dd84d98
--- /dev/null
+++ b/test/language/expressions/function/forbidden-ext/b2/func-expr-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,59 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/func-expr.template
+/*---
+description: Forbidden extension, o.caller (function expression)
+esid: sec-definitions-runtime-semantics-evaluation
+flags: [generated, noStrict]
+info: |
+    FunctionExpression : function ( FormalParameters ) { FunctionBody }
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+var f;
+f = function() {
+  "use strict";
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && true) {
+    Object.defineProperty(inner, "caller", {value: 1});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && true) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+
+  callCount++;
+};
+f();
+assert.sameValue(callCount, 1, 'body evaluated');
diff --git a/test/language/expressions/function/forbidden-ext/b2/func-expr-forbidden-ext-indirect-access-prop-caller.js b/test/language/expressions/function/forbidden-ext/b2/func-expr-forbidden-ext-indirect-access-prop-caller.js
index bd9eea0ac1..016c570cbf 100644
--- a/test/language/expressions/function/forbidden-ext/b2/func-expr-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/expressions/function/forbidden-ext/b2/func-expr-forbidden-ext-indirect-access-prop-caller.js
@@ -8,22 +8,52 @@ flags: [generated, noStrict]
 info: |
     FunctionExpression : function ( FormalParameters ) { FunctionBody }
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 var callCount = 0;
 var f;
 f = function() {
   "use strict";
-  inner().toString();
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && false) {
+    Object.defineProperty(inner, "caller", {});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && false) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+
   callCount++;
 };
-assert.throws(TypeError, function() {
-  f();
-});
-assert.sameValue(callCount, 0, 'method body not evaluated');
+f();
+assert.sameValue(callCount, 1, 'body evaluated');
diff --git a/test/language/expressions/generators/forbidden-ext/b1/gen-func-expr-forbidden-ext-direct-access-prop-arguments.js b/test/language/expressions/generators/forbidden-ext/b1/gen-func-expr-forbidden-ext-direct-access-prop-arguments.js
index 3b102f1931..b2322e6084 100644
--- a/test/language/expressions/generators/forbidden-ext/b1/gen-func-expr-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/expressions/generators/forbidden-ext/b1/gen-func-expr-forbidden-ext-direct-access-prop-arguments.js
@@ -10,18 +10,26 @@ info: |
     GeneratorExpression : function * ( FormalParameters ) { GeneratorBody }
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 var f;
 f = function*() {
-  f.arguments;
+  assert.sameValue(f.hasOwnProperty("arguments"), false);
   callCount++;
 };
 
-assert.throws(TypeError, function() {
-  f().next();
-});
-assert.sameValue(callCount, 0, 'generator function body not evaluated');
+f().next();
+assert.sameValue(callCount, 1, 'generator function body evaluated');
+
diff --git a/test/language/expressions/generators/forbidden-ext/b1/gen-func-expr-forbidden-ext-direct-access-prop-caller.js b/test/language/expressions/generators/forbidden-ext/b1/gen-func-expr-forbidden-ext-direct-access-prop-caller.js
index fa255f6bb0..4549bd9990 100644
--- a/test/language/expressions/generators/forbidden-ext/b1/gen-func-expr-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/expressions/generators/forbidden-ext/b1/gen-func-expr-forbidden-ext-direct-access-prop-caller.js
@@ -10,18 +10,26 @@ info: |
     GeneratorExpression : function * ( FormalParameters ) { GeneratorBody }
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 var f;
 f = function*() {
-  f.caller;
+  assert.sameValue(f.hasOwnProperty("caller"), false);
   callCount++;
 };
 
-assert.throws(TypeError, function() {
-  f().next();
-});
-assert.sameValue(callCount, 0, 'generator function body not evaluated');
+f().next();
+assert.sameValue(callCount, 1, 'generator function body evaluated');
+
diff --git a/test/language/expressions/generators/forbidden-ext/b2/gen-func-expr-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/expressions/generators/forbidden-ext/b2/gen-func-expr-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..e2e48f0336
--- /dev/null
+++ b/test/language/expressions/generators/forbidden-ext/b2/gen-func-expr-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,62 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/gen-func-expr.template
+/*---
+description: Forbidden extension, o.caller (generator function expression)
+esid: sec-generator-definitions-runtime-semantics-evaluation
+features: [generators]
+flags: [generated, noStrict]
+info: |
+    GeneratorExpression : function * ( FormalParameters ) { GeneratorBody }
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+var f;
+f = function*() {
+  "use strict";
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && true) {
+    Object.defineProperty(inner, "caller", {get(){return 1}});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && true) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+
+  callCount++;
+};
+
+f().next();
+assert.sameValue(callCount, 1, 'generator function body evaluated');
diff --git a/test/language/expressions/generators/forbidden-ext/b2/gen-func-expr-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/expressions/generators/forbidden-ext/b2/gen-func-expr-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..d212ba0402
--- /dev/null
+++ b/test/language/expressions/generators/forbidden-ext/b2/gen-func-expr-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,62 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/gen-func-expr.template
+/*---
+description: Forbidden extension, o.caller (generator function expression)
+esid: sec-generator-definitions-runtime-semantics-evaluation
+features: [generators]
+flags: [generated, noStrict]
+info: |
+    GeneratorExpression : function * ( FormalParameters ) { GeneratorBody }
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+var f;
+f = function*() {
+  "use strict";
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && true) {
+    Object.defineProperty(inner, "caller", {value: 1});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && true) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+
+  callCount++;
+};
+
+f().next();
+assert.sameValue(callCount, 1, 'generator function body evaluated');
diff --git a/test/language/expressions/generators/forbidden-ext/b2/gen-func-expr-forbidden-ext-indirect-access-prop-caller.js b/test/language/expressions/generators/forbidden-ext/b2/gen-func-expr-forbidden-ext-indirect-access-prop-caller.js
index cb1812d67c..1c73836cd8 100644
--- a/test/language/expressions/generators/forbidden-ext/b2/gen-func-expr-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/expressions/generators/forbidden-ext/b2/gen-func-expr-forbidden-ext-indirect-access-prop-caller.js
@@ -10,23 +10,53 @@ info: |
     GeneratorExpression : function * ( FormalParameters ) { GeneratorBody }
 
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 var callCount = 0;
 var f;
 f = function*() {
   "use strict";
-  inner().toString();
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && false) {
+    Object.defineProperty(inner, "caller", {});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && false) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+
   callCount++;
 };
 
-assert.throws(TypeError, function() {
-  f().next();
-});
-assert.sameValue(callCount, 0, 'generator function body not evaluated');
+f().next();
+assert.sameValue(callCount, 1, 'generator function body evaluated');
diff --git a/test/language/expressions/object/method-definition/forbidden-ext/b1/async-gen-meth-forbidden-ext-direct-access-prop-arguments.js b/test/language/expressions/object/method-definition/forbidden-ext/b1/async-gen-meth-forbidden-ext-direct-access-prop-arguments.js
index cc2e691bc6..6086aaba8e 100644
--- a/test/language/expressions/object/method-definition/forbidden-ext/b1/async-gen-meth-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/expressions/object/method-definition/forbidden-ext/b1/async-gen-meth-forbidden-ext-direct-access-prop-arguments.js
@@ -4,7 +4,7 @@
 /*---
 description: Forbidden extension, f.arguments (async generator method)
 esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
-features: [async-iteration]
+features: [arrow-function, async-iteration, generators]
 flags: [generated, noStrict, async]
 info: |
     AsyncGeneratorMethod :
@@ -12,23 +12,28 @@ info: |
             { AsyncGeneratorBody }
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 var obj = {
   async *method() {
-    this.method.arguments;
+    assert.sameValue(this.method.hasOwnProperty("arguments"), false);
     callCount++;
   }
 };
 
 obj.method().next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/object/method-definition/forbidden-ext/b1/async-gen-meth-forbidden-ext-direct-access-prop-caller.js b/test/language/expressions/object/method-definition/forbidden-ext/b1/async-gen-meth-forbidden-ext-direct-access-prop-caller.js
index 463f849407..3c081f29ff 100644
--- a/test/language/expressions/object/method-definition/forbidden-ext/b1/async-gen-meth-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/expressions/object/method-definition/forbidden-ext/b1/async-gen-meth-forbidden-ext-direct-access-prop-caller.js
@@ -4,7 +4,7 @@
 /*---
 description: Forbidden extension, o.caller (async generator method)
 esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
-features: [async-iteration]
+features: [arrow-function, async-iteration, generators]
 flags: [generated, noStrict, async]
 info: |
     AsyncGeneratorMethod :
@@ -12,23 +12,28 @@ info: |
             { AsyncGeneratorBody }
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 var obj = {
   async *method() {
-    this.method.caller;
+    assert.sameValue(this.method.hasOwnProperty("caller"), false);
     callCount++;
   }
 };
 
 obj.method().next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/object/method-definition/forbidden-ext/b1/async-meth-forbidden-ext-direct-access-prop-arguments.js b/test/language/expressions/object/method-definition/forbidden-ext/b1/async-meth-forbidden-ext-direct-access-prop-arguments.js
index a88ec7140c..329109f40d 100644
--- a/test/language/expressions/object/method-definition/forbidden-ext/b1/async-meth-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/expressions/object/method-definition/forbidden-ext/b1/async-meth-forbidden-ext-direct-access-prop-arguments.js
@@ -4,14 +4,23 @@
 /*---
 description: Forbidden extension, f.arguments (async method)
 esid: sec-async-function-definitions
-features: [async-functions]
+features: [arrow-function, async-functions]
 flags: [generated, noStrict, async]
 info: |
     AsyncMethod :
       async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody }
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
@@ -20,16 +29,12 @@ var callCount = 0;
 
 var obj = {
   async method() {
-    this.method.arguments;
+    assert.sameValue(this.method.hasOwnProperty("arguments"), false);
     callCount++;
   }
 };
 
 obj.method()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/object/method-definition/forbidden-ext/b1/async-meth-forbidden-ext-direct-access-prop-caller.js b/test/language/expressions/object/method-definition/forbidden-ext/b1/async-meth-forbidden-ext-direct-access-prop-caller.js
index 7e68358870..214cfff47e 100644
--- a/test/language/expressions/object/method-definition/forbidden-ext/b1/async-meth-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/expressions/object/method-definition/forbidden-ext/b1/async-meth-forbidden-ext-direct-access-prop-caller.js
@@ -4,14 +4,23 @@
 /*---
 description: Forbidden extension, o.caller (async method)
 esid: sec-async-function-definitions
-features: [async-functions]
+features: [arrow-function, async-functions]
 flags: [generated, noStrict, async]
 info: |
     AsyncMethod :
       async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody }
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
@@ -20,16 +29,12 @@ var callCount = 0;
 
 var obj = {
   async method() {
-    this.method.caller;
+    assert.sameValue(this.method.hasOwnProperty("caller"), false);
     callCount++;
   }
 };
 
 obj.method()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/object/method-definition/forbidden-ext/b1/gen-meth-forbidden-ext-direct-access-prop-arguments.js b/test/language/expressions/object/method-definition/forbidden-ext/b1/gen-meth-forbidden-ext-direct-access-prop-arguments.js
index 3f9b5660cf..cd8426f843 100644
--- a/test/language/expressions/object/method-definition/forbidden-ext/b1/gen-meth-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/expressions/object/method-definition/forbidden-ext/b1/gen-meth-forbidden-ext-direct-access-prop-arguments.js
@@ -11,19 +11,26 @@ info: |
         * PropertyName ( StrictFormalParameters ) { GeneratorBody }
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 var obj = {
   *method() {
-    this.method.arguments;
+    assert.sameValue(this.method.hasOwnProperty("arguments"), false);
     callCount++;
   }
 };
 
-assert.throws(TypeError, function() {
-  obj.method().next();
-});
-assert.sameValue(callCount, 0, 'generator method body not evaluated');
+obj.method().next();
+assert.sameValue(callCount, 1, 'generator method body evaluated');
diff --git a/test/language/expressions/object/method-definition/forbidden-ext/b1/gen-meth-forbidden-ext-direct-access-prop-caller.js b/test/language/expressions/object/method-definition/forbidden-ext/b1/gen-meth-forbidden-ext-direct-access-prop-caller.js
index e8c23535b8..099f833c75 100644
--- a/test/language/expressions/object/method-definition/forbidden-ext/b1/gen-meth-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/expressions/object/method-definition/forbidden-ext/b1/gen-meth-forbidden-ext-direct-access-prop-caller.js
@@ -11,19 +11,26 @@ info: |
         * PropertyName ( StrictFormalParameters ) { GeneratorBody }
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 var obj = {
   *method() {
-    this.method.caller;
+    assert.sameValue(this.method.hasOwnProperty("caller"), false);
     callCount++;
   }
 };
 
-assert.throws(TypeError, function() {
-  obj.method().next();
-});
-assert.sameValue(callCount, 0, 'generator method body not evaluated');
+obj.method().next();
+assert.sameValue(callCount, 1, 'generator method body evaluated');
diff --git a/test/language/expressions/object/method-definition/forbidden-ext/b1/meth-forbidden-ext-direct-access-prop-arguments.js b/test/language/expressions/object/method-definition/forbidden-ext/b1/meth-forbidden-ext-direct-access-prop-arguments.js
index 270fed6934..0350ac010b 100644
--- a/test/language/expressions/object/method-definition/forbidden-ext/b1/meth-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/expressions/object/method-definition/forbidden-ext/b1/meth-forbidden-ext-direct-access-prop-arguments.js
@@ -8,19 +8,26 @@ flags: [generated, noStrict]
 info: |
     MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody }
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 var obj = {
   method() {
-    this.method.arguments;
+    assert.sameValue(this.method.hasOwnProperty("arguments"), false);
     callCount++;
   }
 };
 
-assert.throws(TypeError, function() {
-  obj.method();
-});
-assert.sameValue(callCount, 0, 'method body not evaluated');
+obj.method();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/expressions/object/method-definition/forbidden-ext/b1/meth-forbidden-ext-direct-access-prop-caller.js b/test/language/expressions/object/method-definition/forbidden-ext/b1/meth-forbidden-ext-direct-access-prop-caller.js
index 3421a3f0ab..cb078f92ee 100644
--- a/test/language/expressions/object/method-definition/forbidden-ext/b1/meth-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/expressions/object/method-definition/forbidden-ext/b1/meth-forbidden-ext-direct-access-prop-caller.js
@@ -8,19 +8,26 @@ flags: [generated, noStrict]
 info: |
     MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody }
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 var obj = {
   method() {
-    this.method.caller;
+    assert.sameValue(this.method.hasOwnProperty("caller"), false);
     callCount++;
   }
 };
 
-assert.throws(TypeError, function() {
-  obj.method();
-});
-assert.sameValue(callCount, 0, 'method body not evaluated');
+obj.method();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/expressions/object/method-definition/forbidden-ext/b2/async-gen-meth-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/expressions/object/method-definition/forbidden-ext/b2/async-gen-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..d9ee9e748b
--- /dev/null
+++ b/test/language/expressions/object/method-definition/forbidden-ext/b2/async-gen-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/async-gen-meth.template
+/*---
+description: Forbidden extension, o.caller (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [arrow-function, async-iteration, generators]
+flags: [generated, noStrict, async]
+info: |
+    AsyncGeneratorMethod :
+        async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+            { AsyncGeneratorBody }
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+var obj = {
+  async *method() {
+    "use strict";
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {get(){return 1}});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+};
+
+obj.method().next()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/object/method-definition/forbidden-ext/b2/async-gen-meth-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/expressions/object/method-definition/forbidden-ext/b2/async-gen-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..a426858977
--- /dev/null
+++ b/test/language/expressions/object/method-definition/forbidden-ext/b2/async-gen-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,65 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/async-gen-meth.template
+/*---
+description: Forbidden extension, o.caller (async generator method)
+esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
+features: [arrow-function, async-iteration, generators]
+flags: [generated, noStrict, async]
+info: |
+    AsyncGeneratorMethod :
+        async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
+            { AsyncGeneratorBody }
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+var obj = {
+  async *method() {
+    "use strict";
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {value: 1});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+};
+
+obj.method().next()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/object/method-definition/forbidden-ext/b2/async-gen-meth-forbidden-ext-indirect-access-prop-caller.js b/test/language/expressions/object/method-definition/forbidden-ext/b2/async-gen-meth-forbidden-ext-indirect-access-prop-caller.js
index 7221cdfe70..4a6e346b27 100644
--- a/test/language/expressions/object/method-definition/forbidden-ext/b2/async-gen-meth-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/expressions/object/method-definition/forbidden-ext/b2/async-gen-meth-forbidden-ext-indirect-access-prop-caller.js
@@ -4,7 +4,7 @@
 /*---
 description: Forbidden extension, o.caller (async generator method)
 esid: sec-asyncgenerator-definitions-propertydefinitionevaluation
-features: [async-iteration]
+features: [arrow-function, async-iteration, generators]
 flags: [generated, noStrict, async]
 info: |
     AsyncGeneratorMethod :
@@ -12,28 +12,54 @@ info: |
             { AsyncGeneratorBody }
 
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 var callCount = 0;
 var obj = {
   async *method() {
     "use strict";
-    inner().toString();
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && false) {
+      Object.defineProperty(inner, "caller", {});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && false) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
     callCount++;
   }
 };
 
 obj.method().next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/object/method-definition/forbidden-ext/b2/async-meth-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/expressions/object/method-definition/forbidden-ext/b2/async-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..a3739f7ca3
--- /dev/null
+++ b/test/language/expressions/object/method-definition/forbidden-ext/b2/async-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,66 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/async-meth.template
+/*---
+description: Forbidden extension, o.caller (async method)
+esid: sec-async-definitions
+features: [arrow-function, async-functions]
+flags: [generated, noStrict, async]
+info: |
+    AsyncMethod :
+     async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody }
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+
+var callCount = 0;
+
+var obj = {
+  async method() {
+    "use strict";
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {get(){return 1}});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+};
+
+obj.method()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/object/method-definition/forbidden-ext/b2/async-meth-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/expressions/object/method-definition/forbidden-ext/b2/async-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..9ff830d325
--- /dev/null
+++ b/test/language/expressions/object/method-definition/forbidden-ext/b2/async-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,66 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/async-meth.template
+/*---
+description: Forbidden extension, o.caller (async method)
+esid: sec-async-definitions
+features: [arrow-function, async-functions]
+flags: [generated, noStrict, async]
+info: |
+    AsyncMethod :
+     async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody }
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+
+var callCount = 0;
+
+var obj = {
+  async method() {
+    "use strict";
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {value: 1});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+};
+
+obj.method()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/object/method-definition/forbidden-ext/b2/async-meth-forbidden-ext-indirect-access-prop-caller.js b/test/language/expressions/object/method-definition/forbidden-ext/b2/async-meth-forbidden-ext-indirect-access-prop-caller.js
index ab0193734f..c4743d372b 100644
--- a/test/language/expressions/object/method-definition/forbidden-ext/b2/async-meth-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/expressions/object/method-definition/forbidden-ext/b2/async-meth-forbidden-ext-indirect-access-prop-caller.js
@@ -4,19 +4,25 @@
 /*---
 description: Forbidden extension, o.caller (async method)
 esid: sec-async-definitions
-features: [async-functions]
+features: [arrow-function, async-functions]
 flags: [generated, noStrict, async]
 info: |
     AsyncMethod :
      async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody }
 
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 
@@ -25,16 +31,36 @@ var callCount = 0;
 var obj = {
   async method() {
     "use strict";
-    inner().toString();
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && false) {
+      Object.defineProperty(inner, "caller", {});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && false) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
     callCount++;
   }
 };
 
 obj.method()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/expressions/object/method-definition/forbidden-ext/b2/gen-meth-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/expressions/object/method-definition/forbidden-ext/b2/gen-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..861d4c9573
--- /dev/null
+++ b/test/language/expressions/object/method-definition/forbidden-ext/b2/gen-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,62 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/gen-meth.template
+/*---
+description: Forbidden extension, o.caller (generator method)
+esid: sec-generator-definitions-runtime-semantics-propertydefinitionevaluation
+features: [generators]
+flags: [generated, noStrict]
+info: |
+    GeneratorMethod :
+        * PropertyName ( StrictFormalParameters ) { GeneratorBody }
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+var obj = {
+  *method() {
+    "use strict";
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {get(){return 1}});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+};
+
+obj.method().next().value;
+assert.sameValue(callCount, 1, 'generator method body was evaluated');
diff --git a/test/language/expressions/object/method-definition/forbidden-ext/b2/gen-meth-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/expressions/object/method-definition/forbidden-ext/b2/gen-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..ba4077cfda
--- /dev/null
+++ b/test/language/expressions/object/method-definition/forbidden-ext/b2/gen-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,62 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/gen-meth.template
+/*---
+description: Forbidden extension, o.caller (generator method)
+esid: sec-generator-definitions-runtime-semantics-propertydefinitionevaluation
+features: [generators]
+flags: [generated, noStrict]
+info: |
+    GeneratorMethod :
+        * PropertyName ( StrictFormalParameters ) { GeneratorBody }
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+var obj = {
+  *method() {
+    "use strict";
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {value: 1});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+};
+
+obj.method().next().value;
+assert.sameValue(callCount, 1, 'generator method body was evaluated');
diff --git a/test/language/expressions/object/method-definition/forbidden-ext/b2/gen-meth-forbidden-ext-indirect-access-prop-caller.js b/test/language/expressions/object/method-definition/forbidden-ext/b2/gen-meth-forbidden-ext-indirect-access-prop-caller.js
index e82942cc57..b4422e9435 100644
--- a/test/language/expressions/object/method-definition/forbidden-ext/b2/gen-meth-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/expressions/object/method-definition/forbidden-ext/b2/gen-meth-forbidden-ext-indirect-access-prop-caller.js
@@ -11,24 +11,52 @@ info: |
         * PropertyName ( StrictFormalParameters ) { GeneratorBody }
 
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 var callCount = 0;
 var obj = {
   *method() {
     "use strict";
-    inner().toString();
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && false) {
+      Object.defineProperty(inner, "caller", {});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && false) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
     callCount++;
   }
 };
 
-assert.throws(TypeError, function() {
-  obj.method().next();
-});
-assert.sameValue(callCount, 0, 'generator method body not evaluated');
+obj.method().next().value;
+assert.sameValue(callCount, 1, 'generator method body was evaluated');
diff --git a/test/language/expressions/object/method-definition/forbidden-ext/b2/meth-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/expressions/object/method-definition/forbidden-ext/b2/meth-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..26bf030742
--- /dev/null
+++ b/test/language/expressions/object/method-definition/forbidden-ext/b2/meth-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,60 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/meth.template
+/*---
+description: Forbidden extension, o.caller (method)
+esid: sec-runtime-semantics-definemethod
+flags: [generated, noStrict]
+info: |
+    MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody }
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+var obj = {
+  method() {
+    "use strict";
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {get(){return 1}});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+
+    callCount++;
+  }
+};
+
+obj.method();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/expressions/object/method-definition/forbidden-ext/b2/meth-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/expressions/object/method-definition/forbidden-ext/b2/meth-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..786f2fa1f0
--- /dev/null
+++ b/test/language/expressions/object/method-definition/forbidden-ext/b2/meth-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,60 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/meth.template
+/*---
+description: Forbidden extension, o.caller (method)
+esid: sec-runtime-semantics-definemethod
+flags: [generated, noStrict]
+info: |
+    MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody }
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+var obj = {
+  method() {
+    "use strict";
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {value: 1});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+
+    callCount++;
+  }
+};
+
+obj.method();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/expressions/object/method-definition/forbidden-ext/b2/meth-forbidden-ext-indirect-access-prop-caller.js b/test/language/expressions/object/method-definition/forbidden-ext/b2/meth-forbidden-ext-indirect-access-prop-caller.js
index acd02d3c59..1994e7151a 100644
--- a/test/language/expressions/object/method-definition/forbidden-ext/b2/meth-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/expressions/object/method-definition/forbidden-ext/b2/meth-forbidden-ext-indirect-access-prop-caller.js
@@ -8,24 +8,53 @@ flags: [generated, noStrict]
 info: |
     MethodDefinition : PropertyName ( StrictFormalParameters ) { FunctionBody }
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 var callCount = 0;
 var obj = {
   method() {
     "use strict";
-    inner().toString();
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && false) {
+      Object.defineProperty(inner, "caller", {});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && false) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+
     callCount++;
   }
 };
 
-assert.throws(TypeError, function() {
-  obj.method();
-});
-assert.sameValue(callCount, 0, 'method body not evaluated');
+obj.method();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/statements/async-function/forbidden-ext/b1/async-func-decl-forbidden-ext-direct-access-prop-arguments.js b/test/language/statements/async-function/forbidden-ext/b1/async-func-decl-forbidden-ext-direct-access-prop-arguments.js
index 1374b8338f..6501f9d93a 100644
--- a/test/language/statements/async-function/forbidden-ext/b1/async-func-decl-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/statements/async-function/forbidden-ext/b1/async-func-decl-forbidden-ext-direct-access-prop-arguments.js
@@ -4,29 +4,34 @@
 /*---
 description: Forbidden extension, f.arguments (async function declaration)
 esid: sec-async-function-definitions
-features: [async-functions]
+features: [arrow-function, async-functions]
 flags: [generated, noStrict, async]
 info: |
     AsyncFunctionDeclaration :
       async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody }
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 
 var callCount = 0;
 async function f() {
-  f.arguments;
+  assert.sameValue(f.hasOwnProperty("arguments"), false);
   callCount++;
 }
 
 f()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/async-function/forbidden-ext/b1/async-func-decl-forbidden-ext-direct-access-prop-caller.js b/test/language/statements/async-function/forbidden-ext/b1/async-func-decl-forbidden-ext-direct-access-prop-caller.js
index 9a9e34316a..048c71efac 100644
--- a/test/language/statements/async-function/forbidden-ext/b1/async-func-decl-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/statements/async-function/forbidden-ext/b1/async-func-decl-forbidden-ext-direct-access-prop-caller.js
@@ -4,29 +4,34 @@
 /*---
 description: Forbidden extension, o.caller (async function declaration)
 esid: sec-async-function-definitions
-features: [async-functions]
+features: [arrow-function, async-functions]
 flags: [generated, noStrict, async]
 info: |
     AsyncFunctionDeclaration :
       async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody }
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 
 var callCount = 0;
 async function f() {
-  f.caller;
+  assert.sameValue(f.hasOwnProperty("caller"), false);
   callCount++;
 }
 
 f()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/async-function/forbidden-ext/b2/async-func-decl-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/statements/async-function/forbidden-ext/b2/async-func-decl-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..061cdc8441
--- /dev/null
+++ b/test/language/statements/async-function/forbidden-ext/b2/async-func-decl-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/async-func-decl.template
+/*---
+description: Forbidden extension, o.caller (async function declaration)
+esid: sec-async-definitions
+features: [arrow-function, async-functions]
+flags: [generated, noStrict, async]
+info: |
+    AsyncFunctionDeclaration :
+      async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody }
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+
+var callCount = 0;
+async function f() {
+  "use strict";
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && true) {
+    Object.defineProperty(inner, "caller", {get(){return 1}});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && true) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+  callCount++;
+}
+
+f()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/async-function/forbidden-ext/b2/async-func-decl-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/statements/async-function/forbidden-ext/b2/async-func-decl-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..5dd4f048b1
--- /dev/null
+++ b/test/language/statements/async-function/forbidden-ext/b2/async-func-decl-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/async-func-decl.template
+/*---
+description: Forbidden extension, o.caller (async function declaration)
+esid: sec-async-definitions
+features: [arrow-function, async-functions]
+flags: [generated, noStrict, async]
+info: |
+    AsyncFunctionDeclaration :
+      async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody }
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+
+var callCount = 0;
+async function f() {
+  "use strict";
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && true) {
+    Object.defineProperty(inner, "caller", {value: 1});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && true) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+  callCount++;
+}
+
+f()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/async-function/forbidden-ext/b2/async-func-decl-forbidden-ext-indirect-access-prop-caller.js b/test/language/statements/async-function/forbidden-ext/b2/async-func-decl-forbidden-ext-indirect-access-prop-caller.js
index 1bae58f64f..fece1c5788 100644
--- a/test/language/statements/async-function/forbidden-ext/b2/async-func-decl-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/statements/async-function/forbidden-ext/b2/async-func-decl-forbidden-ext-indirect-access-prop-caller.js
@@ -4,34 +4,60 @@
 /*---
 description: Forbidden extension, o.caller (async function declaration)
 esid: sec-async-definitions
-features: [async-functions]
+features: [arrow-function, async-functions]
 flags: [generated, noStrict, async]
 info: |
     AsyncFunctionDeclaration :
       async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody }
 
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 
 var callCount = 0;
 async function f() {
   "use strict";
-  inner().toString();
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && false) {
+    Object.defineProperty(inner, "caller", {});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && false) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
   callCount++;
 }
 
 f()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/forbidden-ext/b1/async-gen-func-decl-forbidden-ext-direct-access-prop-arguments.js b/test/language/statements/async-generator/forbidden-ext/b1/async-gen-func-decl-forbidden-ext-direct-access-prop-arguments.js
index 9ce1fc28e9..b05d2b6736 100644
--- a/test/language/statements/async-generator/forbidden-ext/b1/async-gen-func-decl-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/statements/async-generator/forbidden-ext/b1/async-gen-func-decl-forbidden-ext-direct-access-prop-arguments.js
@@ -4,29 +4,34 @@
 /*---
 description: Forbidden extension, f.arguments (async generator function declaration)
 esid: sec-asyncgenerator-definitions-instantiatefunctionobject
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration]
 flags: [generated, noStrict, async]
 info: |
     AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
         ( FormalParameters ) { AsyncGeneratorBody }
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 
 var callCount = 0;
 async function* f() {
-  f.arguments;
+  assert.sameValue(f.hasOwnProperty("arguments"), false);
   callCount++;
 }
 
 f().next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/forbidden-ext/b1/async-gen-func-decl-forbidden-ext-direct-access-prop-caller.js b/test/language/statements/async-generator/forbidden-ext/b1/async-gen-func-decl-forbidden-ext-direct-access-prop-caller.js
index c5be35f3bf..f49a1c00f8 100644
--- a/test/language/statements/async-generator/forbidden-ext/b1/async-gen-func-decl-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/statements/async-generator/forbidden-ext/b1/async-gen-func-decl-forbidden-ext-direct-access-prop-caller.js
@@ -4,29 +4,34 @@
 /*---
 description: Forbidden extension, o.caller (async generator function declaration)
 esid: sec-asyncgenerator-definitions-instantiatefunctionobject
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration]
 flags: [generated, noStrict, async]
 info: |
     AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
         ( FormalParameters ) { AsyncGeneratorBody }
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 
 var callCount = 0;
 async function* f() {
-  f.caller;
+  assert.sameValue(f.hasOwnProperty("caller"), false);
   callCount++;
 }
 
 f().next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/forbidden-ext/b2/async-gen-func-decl-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/statements/async-generator/forbidden-ext/b2/async-gen-func-decl-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..93fb499e9a
--- /dev/null
+++ b/test/language/statements/async-generator/forbidden-ext/b2/async-gen-func-decl-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/async-gen-func-decl.template
+/*---
+description: Forbidden extension, o.caller (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [arrow-function, async-functions, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+    AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+        ( FormalParameters ) { AsyncGeneratorBody }
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+
+var callCount = 0;
+async function* f() {
+  "use strict";
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && true) {
+    Object.defineProperty(inner, "caller", {get(){return 1}});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && true) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+  callCount++;
+}
+
+f().next()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/forbidden-ext/b2/async-gen-func-decl-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/statements/async-generator/forbidden-ext/b2/async-gen-func-decl-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..361b074e61
--- /dev/null
+++ b/test/language/statements/async-generator/forbidden-ext/b2/async-gen-func-decl-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/async-gen-func-decl.template
+/*---
+description: Forbidden extension, o.caller (async generator function declaration)
+esid: sec-asyncgenerator-definitions-instantiatefunctionobject
+features: [arrow-function, async-functions, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+    AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
+        ( FormalParameters ) { AsyncGeneratorBody }
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+
+var callCount = 0;
+async function* f() {
+  "use strict";
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && true) {
+    Object.defineProperty(inner, "caller", {value: 1});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && true) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+  callCount++;
+}
+
+f().next()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/async-generator/forbidden-ext/b2/async-gen-func-decl-forbidden-ext-indirect-access-prop-caller.js b/test/language/statements/async-generator/forbidden-ext/b2/async-gen-func-decl-forbidden-ext-indirect-access-prop-caller.js
index 8f4d3ebe2b..794e245d9b 100644
--- a/test/language/statements/async-generator/forbidden-ext/b2/async-gen-func-decl-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/statements/async-generator/forbidden-ext/b2/async-gen-func-decl-forbidden-ext-indirect-access-prop-caller.js
@@ -4,34 +4,60 @@
 /*---
 description: Forbidden extension, o.caller (async generator function declaration)
 esid: sec-asyncgenerator-definitions-instantiatefunctionobject
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration]
 flags: [generated, noStrict, async]
 info: |
     AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
         ( FormalParameters ) { AsyncGeneratorBody }
 
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 
 var callCount = 0;
 async function* f() {
   "use strict";
-  inner().toString();
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && false) {
+    Object.defineProperty(inner, "caller", {});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && false) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
   callCount++;
 }
 
 f().next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/async-gen-method-static/forbidden-ext/b1/cls-decl-async-gen-meth-static-forbidden-ext-direct-access-prop-arguments.js b/test/language/statements/class/async-gen-method-static/forbidden-ext/b1/cls-decl-async-gen-meth-static-forbidden-ext-direct-access-prop-arguments.js
index 0f820be22b..c78dec5f62 100644
--- a/test/language/statements/class/async-gen-method-static/forbidden-ext/b1/cls-decl-async-gen-meth-static-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/statements/class/async-gen-method-static/forbidden-ext/b1/cls-decl-async-gen-meth-static-forbidden-ext-direct-access-prop-arguments.js
@@ -4,13 +4,22 @@
 /*---
 description: Forbidden extension, f.arguments (static class expression generator method)
 esid: sec-runtime-semantics-bindingclassdeclarationevaluation
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration, class]
 flags: [generated, noStrict, async]
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
@@ -18,16 +27,12 @@ info: |
 var callCount = 0;
 class C {
   static async *method() {
-    this.method.arguments;
+    assert.sameValue(this.method.hasOwnProperty("arguments"), false);
     callCount++;
   }
 }
 
 C.method().next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/async-gen-method-static/forbidden-ext/b1/cls-decl-async-gen-meth-static-forbidden-ext-direct-access-prop-caller.js b/test/language/statements/class/async-gen-method-static/forbidden-ext/b1/cls-decl-async-gen-meth-static-forbidden-ext-direct-access-prop-caller.js
index 857f3efaaf..14d16b323a 100644
--- a/test/language/statements/class/async-gen-method-static/forbidden-ext/b1/cls-decl-async-gen-meth-static-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/statements/class/async-gen-method-static/forbidden-ext/b1/cls-decl-async-gen-meth-static-forbidden-ext-direct-access-prop-caller.js
@@ -4,13 +4,22 @@
 /*---
 description: Forbidden extension, o.caller (static class expression generator method)
 esid: sec-runtime-semantics-bindingclassdeclarationevaluation
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration, class]
 flags: [generated, noStrict, async]
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
@@ -18,16 +27,12 @@ info: |
 var callCount = 0;
 class C {
   static async *method() {
-    this.method.caller;
+    assert.sameValue(this.method.hasOwnProperty("caller"), false);
     callCount++;
   }
 }
 
 C.method().next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/async-gen-method-static/forbidden-ext/b2/cls-decl-async-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/statements/class/async-gen-method-static/forbidden-ext/b2/cls-decl-async-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..772ef77b93
--- /dev/null
+++ b/test/language/statements/class/async-gen-method-static/forbidden-ext/b2/cls-decl-async-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-decl-async-gen-meth-static.template
+/*---
+description: Forbidden extension, o.caller (static class expression generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [arrow-function, async-functions, async-iteration, class]
+flags: [generated, noStrict, async]
+info: |
+    ClassDeclaration : class BindingIdentifier ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+
+var callCount = 0;
+class C {
+  static async *method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {get(){return 1}});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+}
+
+C.method().next()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/async-gen-method-static/forbidden-ext/b2/cls-decl-async-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/statements/class/async-gen-method-static/forbidden-ext/b2/cls-decl-async-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..86a4b4253a
--- /dev/null
+++ b/test/language/statements/class/async-gen-method-static/forbidden-ext/b2/cls-decl-async-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-decl-async-gen-meth-static.template
+/*---
+description: Forbidden extension, o.caller (static class expression generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [arrow-function, async-functions, async-iteration, class]
+flags: [generated, noStrict, async]
+info: |
+    ClassDeclaration : class BindingIdentifier ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+
+var callCount = 0;
+class C {
+  static async *method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {value: 1});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+}
+
+C.method().next()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/async-gen-method-static/forbidden-ext/b2/cls-decl-async-gen-meth-static-forbidden-ext-indirect-access-prop-caller.js b/test/language/statements/class/async-gen-method-static/forbidden-ext/b2/cls-decl-async-gen-meth-static-forbidden-ext-indirect-access-prop-caller.js
index bd96fa1167..85334e2248 100644
--- a/test/language/statements/class/async-gen-method-static/forbidden-ext/b2/cls-decl-async-gen-meth-static-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/statements/class/async-gen-method-static/forbidden-ext/b2/cls-decl-async-gen-meth-static-forbidden-ext-indirect-access-prop-caller.js
@@ -4,18 +4,24 @@
 /*---
 description: Forbidden extension, o.caller (static class expression generator method)
 esid: sec-runtime-semantics-bindingclassdeclarationevaluation
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration, class]
 flags: [generated, noStrict, async]
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
 
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 
@@ -23,16 +29,36 @@ var callCount = 0;
 class C {
   static async *method() {
     /* implicit strict */
-    inner().toString();
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && false) {
+      Object.defineProperty(inner, "caller", {});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && false) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
     callCount++;
   }
 }
 
 C.method().next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/async-gen-method/forbidden-ext/b1/cls-decl-async-gen-meth-forbidden-ext-direct-access-prop-arguments.js b/test/language/statements/class/async-gen-method/forbidden-ext/b1/cls-decl-async-gen-meth-forbidden-ext-direct-access-prop-arguments.js
index c085b86c20..d27627ce5d 100644
--- a/test/language/statements/class/async-gen-method/forbidden-ext/b1/cls-decl-async-gen-meth-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/statements/class/async-gen-method/forbidden-ext/b1/cls-decl-async-gen-meth-forbidden-ext-direct-access-prop-arguments.js
@@ -4,29 +4,34 @@
 /*---
 description: Forbidden extension, f.arguments (class expression method)
 esid: sec-class-definitions-runtime-semantics-evaluation
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration, class, generators]
 flags: [generated, noStrict, async]
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 class C {
   async *method() {
-    this.method.arguments;
+    assert.sameValue(this.method.hasOwnProperty("arguments"), false);
     callCount++;
   }
 }
 
 C.prototype.method().next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/async-gen-method/forbidden-ext/b1/cls-decl-async-gen-meth-forbidden-ext-direct-access-prop-caller.js b/test/language/statements/class/async-gen-method/forbidden-ext/b1/cls-decl-async-gen-meth-forbidden-ext-direct-access-prop-caller.js
index 078824781d..86e301647a 100644
--- a/test/language/statements/class/async-gen-method/forbidden-ext/b1/cls-decl-async-gen-meth-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/statements/class/async-gen-method/forbidden-ext/b1/cls-decl-async-gen-meth-forbidden-ext-direct-access-prop-caller.js
@@ -4,29 +4,34 @@
 /*---
 description: Forbidden extension, o.caller (class expression method)
 esid: sec-class-definitions-runtime-semantics-evaluation
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration, class, generators]
 flags: [generated, noStrict, async]
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 class C {
   async *method() {
-    this.method.caller;
+    assert.sameValue(this.method.hasOwnProperty("caller"), false);
     callCount++;
   }
 }
 
 C.prototype.method().next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/async-gen-method/forbidden-ext/b2/cls-decl-async-gen-meth-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/statements/class/async-gen-method/forbidden-ext/b2/cls-decl-async-gen-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..d6c2b65232
--- /dev/null
+++ b/test/language/statements/class/async-gen-method/forbidden-ext/b2/cls-decl-async-gen-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-decl-async-gen-meth.template
+/*---
+description: Forbidden extension, o.caller (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [arrow-function, async-functions, async-iteration, class]
+flags: [generated, noStrict, async]
+info: |
+    ClassDeclaration : class BindingIdentifier ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+class C {
+  async *method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {get(){return 1}});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+}
+
+C.prototype.method().next()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/async-gen-method/forbidden-ext/b2/cls-decl-async-gen-meth-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/statements/class/async-gen-method/forbidden-ext/b2/cls-decl-async-gen-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..9f68efab8b
--- /dev/null
+++ b/test/language/statements/class/async-gen-method/forbidden-ext/b2/cls-decl-async-gen-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-decl-async-gen-meth.template
+/*---
+description: Forbidden extension, o.caller (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [arrow-function, async-functions, async-iteration, class]
+flags: [generated, noStrict, async]
+info: |
+    ClassDeclaration : class BindingIdentifier ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+class C {
+  async *method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {value: 1});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+}
+
+C.prototype.method().next()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/async-gen-method/forbidden-ext/b2/cls-decl-async-gen-meth-forbidden-ext-indirect-access-prop-caller.js b/test/language/statements/class/async-gen-method/forbidden-ext/b2/cls-decl-async-gen-meth-forbidden-ext-indirect-access-prop-caller.js
index 0fe14854e3..b0222e21ba 100644
--- a/test/language/statements/class/async-gen-method/forbidden-ext/b2/cls-decl-async-gen-meth-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/statements/class/async-gen-method/forbidden-ext/b2/cls-decl-async-gen-meth-forbidden-ext-indirect-access-prop-caller.js
@@ -4,34 +4,60 @@
 /*---
 description: Forbidden extension, o.caller (class expression method)
 esid: sec-class-definitions-runtime-semantics-evaluation
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration, class]
 flags: [generated, noStrict, async]
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
 
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 var callCount = 0;
 class C {
   async *method() {
     /* implicit strict */
-    inner().toString();
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && false) {
+      Object.defineProperty(inner, "caller", {});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && false) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
     callCount++;
   }
 }
 
 C.prototype.method().next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/async-method-static/forbidden-ext/b1/cls-decl-async-meth-static-forbidden-ext-direct-access-prop-arguments.js b/test/language/statements/class/async-method-static/forbidden-ext/b1/cls-decl-async-meth-static-forbidden-ext-direct-access-prop-arguments.js
index 77ddc0c213..ab5c87d663 100644
--- a/test/language/statements/class/async-method-static/forbidden-ext/b1/cls-decl-async-meth-static-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/statements/class/async-method-static/forbidden-ext/b1/cls-decl-async-meth-static-forbidden-ext-direct-access-prop-arguments.js
@@ -4,13 +4,22 @@
 /*---
 description: Forbidden extension, f.arguments (static class declaration async method)
 esid: sec-runtime-semantics-bindingclassdeclarationevaluation
-features: [async-functions]
+features: [arrow-function, async-functions, async-iteration, class]
 flags: [generated, noStrict, async]
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
@@ -18,16 +27,12 @@ info: |
 var callCount = 0;
 class C {
   static async method() {
-    this.method.arguments;
+    assert.sameValue(this.method.hasOwnProperty("arguments"), false);
     callCount++;
   }
 }
 
 C.method()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/async-method-static/forbidden-ext/b1/cls-decl-async-meth-static-forbidden-ext-direct-access-prop-caller.js b/test/language/statements/class/async-method-static/forbidden-ext/b1/cls-decl-async-meth-static-forbidden-ext-direct-access-prop-caller.js
index 60d29c2fc4..e3af911ada 100644
--- a/test/language/statements/class/async-method-static/forbidden-ext/b1/cls-decl-async-meth-static-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/statements/class/async-method-static/forbidden-ext/b1/cls-decl-async-meth-static-forbidden-ext-direct-access-prop-caller.js
@@ -4,13 +4,22 @@
 /*---
 description: Forbidden extension, o.caller (static class declaration async method)
 esid: sec-runtime-semantics-bindingclassdeclarationevaluation
-features: [async-functions]
+features: [arrow-function, async-functions, async-iteration, class]
 flags: [generated, noStrict, async]
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
@@ -18,16 +27,12 @@ info: |
 var callCount = 0;
 class C {
   static async method() {
-    this.method.caller;
+    assert.sameValue(this.method.hasOwnProperty("caller"), false);
     callCount++;
   }
 }
 
 C.method()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/async-method-static/forbidden-ext/b2/cls-decl-async-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/statements/class/async-method-static/forbidden-ext/b2/cls-decl-async-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..6d0b639749
--- /dev/null
+++ b/test/language/statements/class/async-method-static/forbidden-ext/b2/cls-decl-async-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-decl-async-meth-static.template
+/*---
+description: Forbidden extension, o.caller (static class declaration async method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [arrow-function, async-functions, class]
+flags: [generated, noStrict, async]
+info: |
+    ClassDeclaration : class BindingIdentifier ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+
+var callCount = 0;
+class C {
+  static async method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {get(){return 1}});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+}
+
+C.method()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/async-method-static/forbidden-ext/b2/cls-decl-async-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/statements/class/async-method-static/forbidden-ext/b2/cls-decl-async-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..c4c32d3323
--- /dev/null
+++ b/test/language/statements/class/async-method-static/forbidden-ext/b2/cls-decl-async-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-decl-async-meth-static.template
+/*---
+description: Forbidden extension, o.caller (static class declaration async method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [arrow-function, async-functions, class]
+flags: [generated, noStrict, async]
+info: |
+    ClassDeclaration : class BindingIdentifier ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+
+var callCount = 0;
+class C {
+  static async method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {value: 1});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+}
+
+C.method()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/async-method-static/forbidden-ext/b2/cls-decl-async-meth-static-forbidden-ext-indirect-access-prop-caller.js b/test/language/statements/class/async-method-static/forbidden-ext/b2/cls-decl-async-meth-static-forbidden-ext-indirect-access-prop-caller.js
index 6759b66b46..8eba55f6d4 100644
--- a/test/language/statements/class/async-method-static/forbidden-ext/b2/cls-decl-async-meth-static-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/statements/class/async-method-static/forbidden-ext/b2/cls-decl-async-meth-static-forbidden-ext-indirect-access-prop-caller.js
@@ -4,18 +4,24 @@
 /*---
 description: Forbidden extension, o.caller (static class declaration async method)
 esid: sec-runtime-semantics-bindingclassdeclarationevaluation
-features: [async-functions]
+features: [arrow-function, async-functions, class]
 flags: [generated, noStrict, async]
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
 
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 
@@ -23,16 +29,36 @@ var callCount = 0;
 class C {
   static async method() {
     /* implicit strict */
-    inner().toString();
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && false) {
+      Object.defineProperty(inner, "caller", {});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && false) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
     callCount++;
   }
 }
 
 C.method()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/async-method/forbidden-ext/b1/cls-decl-async-meth-forbidden-ext-direct-access-prop-arguments.js b/test/language/statements/class/async-method/forbidden-ext/b1/cls-decl-async-meth-forbidden-ext-direct-access-prop-arguments.js
index 31d22ee2c9..5f581c62ca 100644
--- a/test/language/statements/class/async-method/forbidden-ext/b1/cls-decl-async-meth-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/statements/class/async-method/forbidden-ext/b1/cls-decl-async-meth-forbidden-ext-direct-access-prop-arguments.js
@@ -4,13 +4,22 @@
 /*---
 description: Forbidden extension, f.arguments (class declaration async method)
 esid: sec-class-definitions-runtime-semantics-evaluation
-features: [async-functions]
+features: [arrow-function, async-functions, class]
 flags: [generated, noStrict, async]
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
@@ -18,16 +27,12 @@ info: |
 var callCount = 0;
 class C {
   async method() {
-    this.method.arguments;
+    assert.sameValue(this.method.hasOwnProperty("arguments"), false);
     callCount++;
   }
 }
 
 C.prototype.method()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/async-method/forbidden-ext/b1/cls-decl-async-meth-forbidden-ext-direct-access-prop-caller.js b/test/language/statements/class/async-method/forbidden-ext/b1/cls-decl-async-meth-forbidden-ext-direct-access-prop-caller.js
index 839d78874c..61ac34f7b9 100644
--- a/test/language/statements/class/async-method/forbidden-ext/b1/cls-decl-async-meth-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/statements/class/async-method/forbidden-ext/b1/cls-decl-async-meth-forbidden-ext-direct-access-prop-caller.js
@@ -4,13 +4,22 @@
 /*---
 description: Forbidden extension, o.caller (class declaration async method)
 esid: sec-class-definitions-runtime-semantics-evaluation
-features: [async-functions]
+features: [arrow-function, async-functions, class]
 flags: [generated, noStrict, async]
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
@@ -18,16 +27,12 @@ info: |
 var callCount = 0;
 class C {
   async method() {
-    this.method.caller;
+    assert.sameValue(this.method.hasOwnProperty("caller"), false);
     callCount++;
   }
 }
 
 C.prototype.method()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/async-method/forbidden-ext/b2/cls-decl-async-meth-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/statements/class/async-method/forbidden-ext/b2/cls-decl-async-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..66e2ab3575
--- /dev/null
+++ b/test/language/statements/class/async-method/forbidden-ext/b2/cls-decl-async-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-decl-async-meth.template
+/*---
+description: Forbidden extension, o.caller (class declaration async method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [arrow-function, async-functions, class]
+flags: [generated, noStrict, async]
+info: |
+    ClassDeclaration : class BindingIdentifier ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+
+var callCount = 0;
+class C {
+  async method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {get(){return 1}});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+}
+
+C.prototype.method()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/async-method/forbidden-ext/b2/cls-decl-async-meth-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/statements/class/async-method/forbidden-ext/b2/cls-decl-async-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..bb08b84add
--- /dev/null
+++ b/test/language/statements/class/async-method/forbidden-ext/b2/cls-decl-async-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-decl-async-meth.template
+/*---
+description: Forbidden extension, o.caller (class declaration async method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [arrow-function, async-functions, class]
+flags: [generated, noStrict, async]
+info: |
+    ClassDeclaration : class BindingIdentifier ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+
+var callCount = 0;
+class C {
+  async method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {value: 1});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+}
+
+C.prototype.method()
+  .then(() => {
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/async-method/forbidden-ext/b2/cls-decl-async-meth-forbidden-ext-indirect-access-prop-caller.js b/test/language/statements/class/async-method/forbidden-ext/b2/cls-decl-async-meth-forbidden-ext-indirect-access-prop-caller.js
index 5e5c3d2c6b..532df812ed 100644
--- a/test/language/statements/class/async-method/forbidden-ext/b2/cls-decl-async-meth-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/statements/class/async-method/forbidden-ext/b2/cls-decl-async-meth-forbidden-ext-indirect-access-prop-caller.js
@@ -4,18 +4,24 @@
 /*---
 description: Forbidden extension, o.caller (class declaration async method)
 esid: sec-class-definitions-runtime-semantics-evaluation
-features: [async-functions]
+features: [arrow-function, async-functions, class]
 flags: [generated, noStrict, async]
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
 
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 
@@ -23,16 +29,36 @@ var callCount = 0;
 class C {
   async method() {
     /* implicit strict */
-    inner().toString();
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && false) {
+      Object.defineProperty(inner, "caller", {});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && false) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
     callCount++;
   }
 }
 
 C.prototype.method()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, TypeError))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
-  }, $DONE)
-  .then($DONE, $DONE);
+    assert.sameValue(callCount, 1, 'function body evaluated');
+  }, $DONE).then($DONE, $DONE);
diff --git a/test/language/statements/class/gen-method-static/forbidden-ext/b1/cls-decl-gen-meth-static-forbidden-ext-direct-access-prop-arguments.js b/test/language/statements/class/gen-method-static/forbidden-ext/b1/cls-decl-gen-meth-static-forbidden-ext-direct-access-prop-arguments.js
index af268dc916..bfddb48ec5 100644
--- a/test/language/statements/class/gen-method-static/forbidden-ext/b1/cls-decl-gen-meth-static-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/statements/class/gen-method-static/forbidden-ext/b1/cls-decl-gen-meth-static-forbidden-ext-direct-access-prop-arguments.js
@@ -4,26 +4,33 @@
 /*---
 description: Forbidden extension, f.arguments (static class expression generator method)
 esid: sec-runtime-semantics-bindingclassdeclarationevaluation
-features: [generators]
+features: [class, generators]
 flags: [generated, noStrict]
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 class C {
   static *method() {
-    this.method.arguments;
+    assert.sameValue(this.method.hasOwnProperty("arguments"), false);
     callCount++;
   }
 }
 
-assert.throws(TypeError, function() {
-  C.method().next();
-});
+C.method().next();
+assert.sameValue(callCount, 1, 'method body evaluated');
 
-assert.sameValue(callCount, 0, 'method body not evaluated');
diff --git a/test/language/statements/class/gen-method-static/forbidden-ext/b1/cls-decl-gen-meth-static-forbidden-ext-direct-access-prop-caller.js b/test/language/statements/class/gen-method-static/forbidden-ext/b1/cls-decl-gen-meth-static-forbidden-ext-direct-access-prop-caller.js
index 4b6f85bcf0..ccca11b357 100644
--- a/test/language/statements/class/gen-method-static/forbidden-ext/b1/cls-decl-gen-meth-static-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/statements/class/gen-method-static/forbidden-ext/b1/cls-decl-gen-meth-static-forbidden-ext-direct-access-prop-caller.js
@@ -4,26 +4,33 @@
 /*---
 description: Forbidden extension, o.caller (static class expression generator method)
 esid: sec-runtime-semantics-bindingclassdeclarationevaluation
-features: [generators]
+features: [class, generators]
 flags: [generated, noStrict]
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 class C {
   static *method() {
-    this.method.caller;
+    assert.sameValue(this.method.hasOwnProperty("caller"), false);
     callCount++;
   }
 }
 
-assert.throws(TypeError, function() {
-  C.method().next();
-});
+C.method().next();
+assert.sameValue(callCount, 1, 'method body evaluated');
 
-assert.sameValue(callCount, 0, 'method body not evaluated');
diff --git a/test/language/statements/class/gen-method-static/forbidden-ext/b2/cls-decl-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/statements/class/gen-method-static/forbidden-ext/b2/cls-decl-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..f32c137d00
--- /dev/null
+++ b/test/language/statements/class/gen-method-static/forbidden-ext/b2/cls-decl-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,62 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-decl-gen-meth-static.template
+/*---
+description: Forbidden extension, o.caller (static class expression generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [class, generators]
+flags: [generated, noStrict]
+info: |
+    ClassDeclaration : class BindingIdentifier ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+class C {
+  static *method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {get(){return 1}});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+}
+
+C.method().next();
+
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/statements/class/gen-method-static/forbidden-ext/b2/cls-decl-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/statements/class/gen-method-static/forbidden-ext/b2/cls-decl-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..9e091ba166
--- /dev/null
+++ b/test/language/statements/class/gen-method-static/forbidden-ext/b2/cls-decl-gen-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,62 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-decl-gen-meth-static.template
+/*---
+description: Forbidden extension, o.caller (static class expression generator method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [class, generators]
+flags: [generated, noStrict]
+info: |
+    ClassDeclaration : class BindingIdentifier ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+class C {
+  static *method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {value: 1});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+}
+
+C.method().next();
+
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/statements/class/gen-method-static/forbidden-ext/b2/cls-decl-gen-meth-static-forbidden-ext-indirect-access-prop-caller.js b/test/language/statements/class/gen-method-static/forbidden-ext/b2/cls-decl-gen-meth-static-forbidden-ext-indirect-access-prop-caller.js
index ddaa9147b1..bcd5a8367a 100644
--- a/test/language/statements/class/gen-method-static/forbidden-ext/b2/cls-decl-gen-meth-static-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/statements/class/gen-method-static/forbidden-ext/b2/cls-decl-gen-meth-static-forbidden-ext-indirect-access-prop-caller.js
@@ -4,31 +4,59 @@
 /*---
 description: Forbidden extension, o.caller (static class expression generator method)
 esid: sec-runtime-semantics-bindingclassdeclarationevaluation
-features: [generators]
+features: [class, generators]
 flags: [generated, noStrict]
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
 
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 var callCount = 0;
 class C {
   static *method() {
     /* implicit strict */
-    inner().toString();
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && false) {
+      Object.defineProperty(inner, "caller", {});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && false) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
     callCount++;
   }
 }
 
-assert.throws(TypeError, function() {
-  C.method().next();
-});
+C.method().next();
 
-assert.sameValue(callCount, 0, 'method body not evaluated');
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/statements/class/gen-method/forbidden-ext/b1/cls-decl-gen-meth-forbidden-ext-direct-access-prop-arguments.js b/test/language/statements/class/gen-method/forbidden-ext/b1/cls-decl-gen-meth-forbidden-ext-direct-access-prop-arguments.js
index 6498eeb494..5d167ba6a2 100644
--- a/test/language/statements/class/gen-method/forbidden-ext/b1/cls-decl-gen-meth-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/statements/class/gen-method/forbidden-ext/b1/cls-decl-gen-meth-forbidden-ext-direct-access-prop-arguments.js
@@ -4,25 +4,32 @@
 /*---
 description: Forbidden extension, f.arguments (class expression method)
 esid: sec-class-definitions-runtime-semantics-evaluation
-features: [generators]
+features: [class, generators]
 flags: [generated, noStrict]
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 class C {
   *method() {
-    this.method.arguments;
+    assert.sameValue(this.method.hasOwnProperty("arguments"), false);
     callCount++;
   }
 }
 
-assert.throws(TypeError, function() {
-  C.prototype.method().next();
-});
-assert.sameValue(callCount, 0, 'method body not evaluated');
+C.prototype.method().next();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/statements/class/gen-method/forbidden-ext/b1/cls-decl-gen-meth-forbidden-ext-direct-access-prop-caller.js b/test/language/statements/class/gen-method/forbidden-ext/b1/cls-decl-gen-meth-forbidden-ext-direct-access-prop-caller.js
index 7bbd9dcb89..16e7153e98 100644
--- a/test/language/statements/class/gen-method/forbidden-ext/b1/cls-decl-gen-meth-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/statements/class/gen-method/forbidden-ext/b1/cls-decl-gen-meth-forbidden-ext-direct-access-prop-caller.js
@@ -4,25 +4,32 @@
 /*---
 description: Forbidden extension, o.caller (class expression method)
 esid: sec-class-definitions-runtime-semantics-evaluation
-features: [generators]
+features: [class, generators]
 flags: [generated, noStrict]
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 class C {
   *method() {
-    this.method.caller;
+    assert.sameValue(this.method.hasOwnProperty("caller"), false);
     callCount++;
   }
 }
 
-assert.throws(TypeError, function() {
-  C.prototype.method().next();
-});
-assert.sameValue(callCount, 0, 'method body not evaluated');
+C.prototype.method().next();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/statements/class/gen-method/forbidden-ext/b2/cls-decl-gen-meth-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/statements/class/gen-method/forbidden-ext/b2/cls-decl-gen-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..1db39d462a
--- /dev/null
+++ b/test/language/statements/class/gen-method/forbidden-ext/b2/cls-decl-gen-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,61 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-decl-gen-meth.template
+/*---
+description: Forbidden extension, o.caller (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [class, generators]
+flags: [generated, noStrict]
+info: |
+    ClassDeclaration : class BindingIdentifier ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+class C {
+  *method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {get(){return 1}});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+}
+
+C.prototype.method().next();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/statements/class/gen-method/forbidden-ext/b2/cls-decl-gen-meth-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/statements/class/gen-method/forbidden-ext/b2/cls-decl-gen-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..bfb18fbc13
--- /dev/null
+++ b/test/language/statements/class/gen-method/forbidden-ext/b2/cls-decl-gen-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,61 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-decl-gen-meth.template
+/*---
+description: Forbidden extension, o.caller (class expression method)
+esid: sec-class-definitions-runtime-semantics-evaluation
+features: [class, generators]
+flags: [generated, noStrict]
+info: |
+    ClassDeclaration : class BindingIdentifier ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+class C {
+  *method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {value: 1});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+}
+
+C.prototype.method().next();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/statements/class/gen-method/forbidden-ext/b2/cls-decl-gen-meth-forbidden-ext-indirect-access-prop-caller.js b/test/language/statements/class/gen-method/forbidden-ext/b2/cls-decl-gen-meth-forbidden-ext-indirect-access-prop-caller.js
index 84169dc998..eae2345f61 100644
--- a/test/language/statements/class/gen-method/forbidden-ext/b2/cls-decl-gen-meth-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/statements/class/gen-method/forbidden-ext/b2/cls-decl-gen-meth-forbidden-ext-indirect-access-prop-caller.js
@@ -4,30 +4,58 @@
 /*---
 description: Forbidden extension, o.caller (class expression method)
 esid: sec-class-definitions-runtime-semantics-evaluation
-features: [generators]
+features: [class, generators]
 flags: [generated, noStrict]
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
 
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 var callCount = 0;
 class C {
   *method() {
     /* implicit strict */
-    inner().toString();
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && false) {
+      Object.defineProperty(inner, "caller", {});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && false) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
     callCount++;
   }
 }
 
-assert.throws(TypeError, function() {
-  C.prototype.method().next();
-});
-assert.sameValue(callCount, 0, 'method body not evaluated');
+C.prototype.method().next();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/statements/class/method-static/forbidden-ext/b1/cls-decl-meth-static-forbidden-ext-direct-access-prop-arguments.js b/test/language/statements/class/method-static/forbidden-ext/b1/cls-decl-meth-static-forbidden-ext-direct-access-prop-arguments.js
index 556b2f1889..386aca094a 100644
--- a/test/language/statements/class/method-static/forbidden-ext/b1/cls-decl-meth-static-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/statements/class/method-static/forbidden-ext/b1/cls-decl-meth-static-forbidden-ext-direct-access-prop-arguments.js
@@ -4,23 +4,32 @@
 /*---
 description: Forbidden extension, f.arguments (static class expression method)
 esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [class]
 flags: [generated, noStrict]
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 class C {
   static method() {
-    this.method.arguments;
+    assert.sameValue(this.method.hasOwnProperty("arguments"), false);
     callCount++;
   }
 }
 
-assert.throws(TypeError, function() {
-  C.method();
-});
-assert.sameValue(callCount, 0, 'method body not evaluated');
+C.method();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/statements/class/method-static/forbidden-ext/b1/cls-decl-meth-static-forbidden-ext-direct-access-prop-caller.js b/test/language/statements/class/method-static/forbidden-ext/b1/cls-decl-meth-static-forbidden-ext-direct-access-prop-caller.js
index cadd1d3ce5..76bdf5132a 100644
--- a/test/language/statements/class/method-static/forbidden-ext/b1/cls-decl-meth-static-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/statements/class/method-static/forbidden-ext/b1/cls-decl-meth-static-forbidden-ext-direct-access-prop-caller.js
@@ -4,23 +4,32 @@
 /*---
 description: Forbidden extension, o.caller (static class expression method)
 esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [class]
 flags: [generated, noStrict]
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 class C {
   static method() {
-    this.method.caller;
+    assert.sameValue(this.method.hasOwnProperty("caller"), false);
     callCount++;
   }
 }
 
-assert.throws(TypeError, function() {
-  C.method();
-});
-assert.sameValue(callCount, 0, 'method body not evaluated');
+C.method();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/statements/class/method-static/forbidden-ext/b2/cls-decl-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/statements/class/method-static/forbidden-ext/b2/cls-decl-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..97d5e540d3
--- /dev/null
+++ b/test/language/statements/class/method-static/forbidden-ext/b2/cls-decl-meth-static-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,61 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-decl-meth-static.template
+/*---
+description: Forbidden extension, o.caller (static class expression method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [class]
+flags: [generated, noStrict]
+info: |
+    ClassDeclaration : class BindingIdentifier ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+class C {
+  static method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {get(){return 1}});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+}
+
+C.method();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/statements/class/method-static/forbidden-ext/b2/cls-decl-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/statements/class/method-static/forbidden-ext/b2/cls-decl-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..a0b0383c64
--- /dev/null
+++ b/test/language/statements/class/method-static/forbidden-ext/b2/cls-decl-meth-static-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,61 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-decl-meth-static.template
+/*---
+description: Forbidden extension, o.caller (static class expression method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [class]
+flags: [generated, noStrict]
+info: |
+    ClassDeclaration : class BindingIdentifier ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+class C {
+  static method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {value: 1});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+}
+
+C.method();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/statements/class/method-static/forbidden-ext/b2/cls-decl-meth-static-forbidden-ext-indirect-access-prop-caller.js b/test/language/statements/class/method-static/forbidden-ext/b2/cls-decl-meth-static-forbidden-ext-indirect-access-prop-caller.js
index d83509b4f2..f0b60a10ae 100644
--- a/test/language/statements/class/method-static/forbidden-ext/b2/cls-decl-meth-static-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/statements/class/method-static/forbidden-ext/b2/cls-decl-meth-static-forbidden-ext-indirect-access-prop-caller.js
@@ -4,28 +4,58 @@
 /*---
 description: Forbidden extension, o.caller (static class expression method)
 esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [class]
 flags: [generated, noStrict]
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 var callCount = 0;
 class C {
   static method() {
     /* implicit strict */
-    inner().toString();
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && false) {
+      Object.defineProperty(inner, "caller", {});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && false) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
     callCount++;
   }
 }
 
-assert.throws(TypeError, function() {
-  C.method();
-});
-assert.sameValue(callCount, 0, 'method body not evaluated');
+C.method();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/statements/class/method/forbidden-ext/b1/cls-decl-meth-forbidden-ext-direct-access-prop-arguments.js b/test/language/statements/class/method/forbidden-ext/b1/cls-decl-meth-forbidden-ext-direct-access-prop-arguments.js
index 4cf2df46b7..fbd627a05d 100644
--- a/test/language/statements/class/method/forbidden-ext/b1/cls-decl-meth-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/statements/class/method/forbidden-ext/b1/cls-decl-meth-forbidden-ext-direct-access-prop-arguments.js
@@ -4,23 +4,32 @@
 /*---
 description: Forbidden extension, f.arguments (class expression method)
 esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [class]
 flags: [generated, noStrict]
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 class C {
   method() {
-    this.method.arguments;
+    assert.sameValue(this.method.hasOwnProperty("arguments"), false);
     callCount++;
   }
 }
 
-assert.throws(TypeError, function() {
-  C.prototype.method();
-});
-assert.sameValue(callCount, 0, 'method body not evaluated');
+C.prototype.method();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/statements/class/method/forbidden-ext/b1/cls-decl-meth-forbidden-ext-direct-access-prop-caller.js b/test/language/statements/class/method/forbidden-ext/b1/cls-decl-meth-forbidden-ext-direct-access-prop-caller.js
index 4d6557f1b5..620b2a5ffb 100644
--- a/test/language/statements/class/method/forbidden-ext/b1/cls-decl-meth-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/statements/class/method/forbidden-ext/b1/cls-decl-meth-forbidden-ext-direct-access-prop-caller.js
@@ -4,23 +4,32 @@
 /*---
 description: Forbidden extension, o.caller (class expression method)
 esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [class]
 flags: [generated, noStrict]
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 class C {
   method() {
-    this.method.caller;
+    assert.sameValue(this.method.hasOwnProperty("caller"), false);
     callCount++;
   }
 }
 
-assert.throws(TypeError, function() {
-  C.prototype.method();
-});
-assert.sameValue(callCount, 0, 'method body not evaluated');
+C.prototype.method();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/statements/class/method/forbidden-ext/b2/cls-decl-meth-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/statements/class/method/forbidden-ext/b2/cls-decl-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..3d02d1c23e
--- /dev/null
+++ b/test/language/statements/class/method/forbidden-ext/b2/cls-decl-meth-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,61 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-decl-meth.template
+/*---
+description: Forbidden extension, o.caller (class expression method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [class]
+flags: [generated, noStrict]
+info: |
+    ClassDeclaration : class BindingIdentifier ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+class C {
+  method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {get(){return 1}});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+}
+
+C.prototype.method();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/statements/class/method/forbidden-ext/b2/cls-decl-meth-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/statements/class/method/forbidden-ext/b2/cls-decl-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..ef31f0ad10
--- /dev/null
+++ b/test/language/statements/class/method/forbidden-ext/b2/cls-decl-meth-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,61 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/cls-decl-meth.template
+/*---
+description: Forbidden extension, o.caller (class expression method)
+esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [class]
+flags: [generated, noStrict]
+info: |
+    ClassDeclaration : class BindingIdentifier ClassTail
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+class C {
+  method() {
+    /* implicit strict */
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && true) {
+      Object.defineProperty(inner, "caller", {value: 1});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && true) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
+    callCount++;
+  }
+}
+
+C.prototype.method();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/statements/class/method/forbidden-ext/b2/cls-decl-meth-forbidden-ext-indirect-access-prop-caller.js b/test/language/statements/class/method/forbidden-ext/b2/cls-decl-meth-forbidden-ext-indirect-access-prop-caller.js
index 6ad824526c..385bb808ac 100644
--- a/test/language/statements/class/method/forbidden-ext/b2/cls-decl-meth-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/statements/class/method/forbidden-ext/b2/cls-decl-meth-forbidden-ext-indirect-access-prop-caller.js
@@ -4,28 +4,58 @@
 /*---
 description: Forbidden extension, o.caller (class expression method)
 esid: sec-runtime-semantics-bindingclassdeclarationevaluation
+features: [class]
 flags: [generated, noStrict]
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 var callCount = 0;
 class C {
   method() {
     /* implicit strict */
-    inner().toString();
+    // This and the following conditional value is set in the test's .case file.
+    // For every test that has a "true" value here, there is a
+    // corresponding test that has a "false" value here.
+    // They are generated from two different case files, which use
+    let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+    if (descriptor && descriptor.configurable && false) {
+      Object.defineProperty(inner, "caller", {});
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && false) {
+      assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+    }
+
+    // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+    // forbidden-ext-indirect-access-prop-caller.case
+    //
+    // If the function object "inner" has an own property
+    // named "caller", then its value will be returned.
+    //
+    // If the function object "inner" DOES NOT have an
+    // own property named "caller", then the symbol
+    // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+    if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+      assert.notSameValue(result, this.method);
+    }
     callCount++;
   }
 }
 
-assert.throws(TypeError, function() {
-  C.prototype.method();
-});
-assert.sameValue(callCount, 0, 'method body not evaluated');
+C.prototype.method();
+assert.sameValue(callCount, 1, 'method body evaluated');
diff --git a/test/language/statements/function/forbidden-ext/b1/cls-expr-meth-forbidden-ext-direct-access-prop-arguments.js b/test/language/statements/function/forbidden-ext/b1/cls-expr-meth-forbidden-ext-direct-access-prop-arguments.js
index 68c43b5609..553da27278 100644
--- a/test/language/statements/function/forbidden-ext/b1/cls-expr-meth-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/statements/function/forbidden-ext/b1/cls-expr-meth-forbidden-ext-direct-access-prop-arguments.js
@@ -9,17 +9,25 @@ info: |
     FunctionDeclaration :
         function BindingIdentifier ( FormalParameters ) { FunctionBody }
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 function f() {
   "use strict";
-  f.arguments;
+  assert.sameValue(f.hasOwnProperty("arguments"), false);
   callCount++;
 }
-assert.throws(TypeError, function() {
-  f();
-});
-assert.sameValue(callCount, 0, 'function body not evaluated');
+
+f();
+assert.sameValue(callCount, 1, 'function body evaluated');
diff --git a/test/language/statements/function/forbidden-ext/b1/cls-expr-meth-forbidden-ext-direct-access-prop-caller.js b/test/language/statements/function/forbidden-ext/b1/cls-expr-meth-forbidden-ext-direct-access-prop-caller.js
index 8ab8c5efd9..930e01fdc7 100644
--- a/test/language/statements/function/forbidden-ext/b1/cls-expr-meth-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/statements/function/forbidden-ext/b1/cls-expr-meth-forbidden-ext-direct-access-prop-caller.js
@@ -9,17 +9,25 @@ info: |
     FunctionDeclaration :
         function BindingIdentifier ( FormalParameters ) { FunctionBody }
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 function f() {
   "use strict";
-  f.caller;
+  assert.sameValue(f.hasOwnProperty("caller"), false);
   callCount++;
 }
-assert.throws(TypeError, function() {
-  f();
-});
-assert.sameValue(callCount, 0, 'function body not evaluated');
+
+f();
+assert.sameValue(callCount, 1, 'function body evaluated');
diff --git a/test/language/statements/function/forbidden-ext/b1/func-decl-forbidden-ext-direct-access-prop-arguments.js b/test/language/statements/function/forbidden-ext/b1/func-decl-forbidden-ext-direct-access-prop-arguments.js
deleted file mode 100644
index 8f1e6fd20c..0000000000
--- a/test/language/statements/function/forbidden-ext/b1/func-decl-forbidden-ext-direct-access-prop-arguments.js
+++ /dev/null
@@ -1,25 +0,0 @@
-// This file was procedurally generated from the following sources:
-// - src/function-forms/forbidden-ext-direct-access-prop-arguments.case
-// - src/function-forms/forbidden-extensions/bullet-one/func-decl.template
-/*---
-description: Forbidden extension, f.arguments (function declaration)
-esid: sec-function-definitions-runtime-semantics-instantiatefunctionobject
-flags: [generated, noStrict]
-info: |
-    FunctionDeclaration :
-        function BindingIdentifier ( FormalParameters ) { FunctionBody }
-
-    In non-strict mode code, a function object created using the FunctionDeclaration
-    syntactic constructor, is not subject to the following forbidden extension:
-
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
-
----*/
-
-var callCount = 0;
-function f() {
-  f.arguments;
-  callCount++;
-}
-f();
-assert.sameValue(callCount, 1, 'function was evaluated');
diff --git a/test/language/statements/function/forbidden-ext/b1/func-decl-forbidden-ext-direct-access-prop-caller.js b/test/language/statements/function/forbidden-ext/b1/func-decl-forbidden-ext-direct-access-prop-caller.js
deleted file mode 100644
index f7bc5989a1..0000000000
--- a/test/language/statements/function/forbidden-ext/b1/func-decl-forbidden-ext-direct-access-prop-caller.js
+++ /dev/null
@@ -1,25 +0,0 @@
-// This file was procedurally generated from the following sources:
-// - src/function-forms/forbidden-ext-direct-access-prop-caller.case
-// - src/function-forms/forbidden-extensions/bullet-one/func-decl.template
-/*---
-description: Forbidden extension, o.caller (function declaration)
-esid: sec-function-definitions-runtime-semantics-instantiatefunctionobject
-flags: [generated, noStrict]
-info: |
-    FunctionDeclaration :
-        function BindingIdentifier ( FormalParameters ) { FunctionBody }
-
-    In non-strict mode code, a function object created using the FunctionDeclaration
-    syntactic constructor, is not subject to the following forbidden extension:
-
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
-
----*/
-
-var callCount = 0;
-function f() {
-  f.caller;
-  callCount++;
-}
-f();
-assert.sameValue(callCount, 1, 'function was evaluated');
diff --git a/test/language/statements/function/forbidden-ext/b2/func-decl-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/statements/function/forbidden-ext/b2/func-decl-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..9c45045988
--- /dev/null
+++ b/test/language/statements/function/forbidden-ext/b2/func-decl-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,59 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/func-decl.template
+/*---
+description: Forbidden extension, o.caller (function declaration)
+esid: sec-definitions-runtime-semantics-instantiatefunctionobject
+flags: [generated, noStrict]
+info: |
+    FunctionDeclaration :
+        function BindingIdentifier ( FormalParameters ) { FunctionBody }
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+function f() {
+  "use strict";
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && true) {
+    Object.defineProperty(inner, "caller", {get(){return 1}});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && true) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+
+  callCount++;
+}
+f();
+assert.sameValue(callCount, 1, 'body evaluated');
diff --git a/test/language/statements/function/forbidden-ext/b2/func-decl-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/statements/function/forbidden-ext/b2/func-decl-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..3950f02af7
--- /dev/null
+++ b/test/language/statements/function/forbidden-ext/b2/func-decl-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,59 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/func-decl.template
+/*---
+description: Forbidden extension, o.caller (function declaration)
+esid: sec-definitions-runtime-semantics-instantiatefunctionobject
+flags: [generated, noStrict]
+info: |
+    FunctionDeclaration :
+        function BindingIdentifier ( FormalParameters ) { FunctionBody }
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+function f() {
+  "use strict";
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && true) {
+    Object.defineProperty(inner, "caller", {value: 1});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && true) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+
+  callCount++;
+}
+f();
+assert.sameValue(callCount, 1, 'body evaluated');
diff --git a/test/language/statements/function/forbidden-ext/b2/func-decl-forbidden-ext-indirect-access-prop-caller.js b/test/language/statements/function/forbidden-ext/b2/func-decl-forbidden-ext-indirect-access-prop-caller.js
index d55dc84579..3d4429ad4c 100644
--- a/test/language/statements/function/forbidden-ext/b2/func-decl-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/statements/function/forbidden-ext/b2/func-decl-forbidden-ext-indirect-access-prop-caller.js
@@ -9,21 +9,51 @@ info: |
     FunctionDeclaration :
         function BindingIdentifier ( FormalParameters ) { FunctionBody }
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 var callCount = 0;
 function f() {
   "use strict";
-  inner().toString();
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && false) {
+    Object.defineProperty(inner, "caller", {});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && false) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+
   callCount++;
 }
-assert.throws(TypeError, function() {
-  f();
-});
-assert.sameValue(callCount, 0, 'method body not evaluated');
+f();
+assert.sameValue(callCount, 1, 'body evaluated');
diff --git a/test/language/statements/generators/forbidden-ext/b1/gen-func-decl-forbidden-ext-direct-access-prop-arguments.js b/test/language/statements/generators/forbidden-ext/b1/gen-func-decl-forbidden-ext-direct-access-prop-arguments.js
index a9c5809953..f548b3738d 100644
--- a/test/language/statements/generators/forbidden-ext/b1/gen-func-decl-forbidden-ext-direct-access-prop-arguments.js
+++ b/test/language/statements/generators/forbidden-ext/b1/gen-func-decl-forbidden-ext-direct-access-prop-arguments.js
@@ -10,18 +10,25 @@ info: |
     GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody }
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 function* f() {
-  f.arguments;
+  assert.sameValue(f.hasOwnProperty("arguments"), false);
   callCount++;
 }
 
-assert.throws(TypeError, function() {
-  f().next();
-});
+f().next();
+assert.sameValue(callCount, 1, 'generator function body evaluated');
 
-assert.sameValue(callCount, 0, 'generator function body not evaluated');
diff --git a/test/language/statements/generators/forbidden-ext/b1/gen-func-decl-forbidden-ext-direct-access-prop-caller.js b/test/language/statements/generators/forbidden-ext/b1/gen-func-decl-forbidden-ext-direct-access-prop-caller.js
index 9ce5e21a57..cbd481e8be 100644
--- a/test/language/statements/generators/forbidden-ext/b1/gen-func-decl-forbidden-ext-direct-access-prop-caller.js
+++ b/test/language/statements/generators/forbidden-ext/b1/gen-func-decl-forbidden-ext-direct-access-prop-caller.js
@@ -10,18 +10,25 @@ info: |
     GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody }
 
 
-    ECMAScript function objects defined using syntactic constructors in strict mode code must not be created with own properties named "caller" or "arguments". Such own properties also must not be created for function objects defined using an ArrowFunction, MethodDefinition, GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression, ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or AsyncArrowFunction regardless of whether the definition is contained in strict mode code. Built-in functions, strict functions created using the Function constructor, generator functions created using the Generator constructor, async functions created using the AsyncFunction constructor, and functions created using the bind method also must not be created with such own properties.
+    ECMAScript function objects defined using syntactic constructors in strict mode code must
+    not be created with own properties named "caller" or "arguments". Such own properties also
+    must not be created for function objects defined using an ArrowFunction, MethodDefinition,
+    GeneratorDeclaration, GeneratorExpression, AsyncGeneratorDeclaration, AsyncGeneratorExpression,
+    ClassDeclaration, ClassExpression, AsyncFunctionDeclaration, AsyncFunctionExpression, or
+    AsyncArrowFunction regardless of whether the definition is contained in strict mode code.
+    Built-in functions, strict functions created using the Function constructor, generator functions
+    created using the Generator constructor, async functions created using the AsyncFunction
+    constructor, and functions created using the bind method also must not be created with such own
+    properties.
 
 ---*/
 
 var callCount = 0;
 function* f() {
-  f.caller;
+  assert.sameValue(f.hasOwnProperty("caller"), false);
   callCount++;
 }
 
-assert.throws(TypeError, function() {
-  f().next();
-});
+f().next();
+assert.sameValue(callCount, 1, 'generator function body evaluated');
 
-assert.sameValue(callCount, 0, 'generator function body not evaluated');
diff --git a/test/language/statements/generators/forbidden-ext/b2/gen-func-decl-forbidden-ext-indirect-access-own-prop-caller-get.js b/test/language/statements/generators/forbidden-ext/b2/gen-func-decl-forbidden-ext-indirect-access-own-prop-caller-get.js
new file mode 100644
index 0000000000..fe173263c5
--- /dev/null
+++ b/test/language/statements/generators/forbidden-ext/b2/gen-func-decl-forbidden-ext-indirect-access-own-prop-caller-get.js
@@ -0,0 +1,62 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case
+// - src/function-forms/forbidden-extensions/bullet-two/gen-func-decl.template
+/*---
+description: Forbidden extension, o.caller (generator function declaration)
+esid: sec-generator-definitions-runtime-semantics-instantiatefunctionobject
+features: [generators]
+flags: [generated, noStrict]
+info: |
+    GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody }
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+function* f() {
+  "use strict";
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && true) {
+    Object.defineProperty(inner, "caller", {get(){return 1}});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && true) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+
+  callCount++;
+}
+
+f().next();
+
+assert.sameValue(callCount, 1, 'generator function body evaluated');
diff --git a/test/language/statements/generators/forbidden-ext/b2/gen-func-decl-forbidden-ext-indirect-access-own-prop-caller-value.js b/test/language/statements/generators/forbidden-ext/b2/gen-func-decl-forbidden-ext-indirect-access-own-prop-caller-value.js
new file mode 100644
index 0000000000..ced3756d2e
--- /dev/null
+++ b/test/language/statements/generators/forbidden-ext/b2/gen-func-decl-forbidden-ext-indirect-access-own-prop-caller-value.js
@@ -0,0 +1,62 @@
+// This file was procedurally generated from the following sources:
+// - src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case
+// - src/function-forms/forbidden-extensions/bullet-two/gen-func-decl.template
+/*---
+description: Forbidden extension, o.caller (generator function declaration)
+esid: sec-generator-definitions-runtime-semantics-instantiatefunctionobject
+features: [generators]
+flags: [generated, noStrict]
+info: |
+    GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody }
+
+
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
+
+---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
+function inner() {
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
+}
+
+var callCount = 0;
+function* f() {
+  "use strict";
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && true) {
+    Object.defineProperty(inner, "caller", {value: 1});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && true) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+
+  callCount++;
+}
+
+f().next();
+
+assert.sameValue(callCount, 1, 'generator function body evaluated');
diff --git a/test/language/statements/generators/forbidden-ext/b2/gen-func-decl-forbidden-ext-indirect-access-prop-caller.js b/test/language/statements/generators/forbidden-ext/b2/gen-func-decl-forbidden-ext-indirect-access-prop-caller.js
index e752ae32d2..fffa10f78f 100644
--- a/test/language/statements/generators/forbidden-ext/b2/gen-func-decl-forbidden-ext-indirect-access-prop-caller.js
+++ b/test/language/statements/generators/forbidden-ext/b2/gen-func-decl-forbidden-ext-indirect-access-prop-caller.js
@@ -10,23 +10,53 @@ info: |
     GeneratorDeclaration : function * ( FormalParameters ) { GeneratorBody }
 
 
-    If an implementation extends any function object with an own property named "caller" the value of that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function object. If it is an accessor property, the function that is the value of the property's [[Get]] attribute must never return a strict function when called.
+    If an implementation extends any function object with an own property named "caller" the value of
+    that property, as observed using [[Get]] or [[GetOwnProperty]], must not be a strict function
+    object. If it is an accessor property, the function that is the value of the property's [[Get]]
+    attribute must never return a strict function when called.
 
 ---*/
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
-  return inner.caller;
+  // This property may exist, but is forbidden from having a value that is a strict function object
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
 
 var callCount = 0;
 function* f() {
   "use strict";
-  inner().toString();
+  // This and the following conditional value is set in the test's .case file.
+  // For every test that has a "true" value here, there is a
+  // corresponding test that has a "false" value here.
+  // They are generated from two different case files, which use
+  // the same templates.
+  let descriptor = Object.getOwnPropertyDescriptor(inner, "caller");
+  if (descriptor && descriptor.configurable && false) {
+    Object.defineProperty(inner, "caller", {});
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && false) {
+    assert.sameValue(result, 1, 'If this test defined an own "caller" property on the inner function, then it should be accessible and should return the value it was set to.');
+  }
+
+  // "CALLER_OWN_PROPERTY_DOES_NOT_EXIST" is from
+  // forbidden-ext-indirect-access-prop-caller.case
+  //
+  // If the function object "inner" has an own property
+  // named "caller", then its value will be returned.
+  //
+  // If the function object "inner" DOES NOT have an
+  // own property named "caller", then the symbol
+  // CALLER_OWN_PROPERTY_DOES_NOT_EXIST will be returned.
+  if (result !== CALLER_OWN_PROPERTY_DOES_NOT_EXIST) {
+    assert.notSameValue(result, f);
+  }
+
   callCount++;
 }
 
-assert.throws(TypeError, function() {
-  f().next();
-});
+f().next();
 
-assert.sameValue(callCount, 0, 'generator function body not evaluated');
+assert.sameValue(callCount, 1, 'generator function body evaluated');