Forbidden Extensions: revised to check property existence

src/function-forms/forbidden-ext-direct-access-prop-arguments.case

@@ -6,14 +6,23 @@ esid: sec-forbidden-extensions
 desc: >
   Forbidden extension, f.arguments
 info: |
-  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.
 
 flags: [noStrict]
 ---*/
 
-//- function-body
+//- function-has-forbidden-property
-f.arguments;
+f.hasOwnProperty("arguments")
-//- method-body
+//- method-has-forbidden-property
-this.method.arguments;
+this.method.hasOwnProperty("arguments")
 //- error
 TypeError

src/function-forms/forbidden-ext-direct-access-prop-caller.case

@@ -6,14 +6,23 @@ esid: sec-forbidden-extensions
 desc: >
   Forbidden extension, o.caller
 info: |
-  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.
 
 flags: [noStrict]
 ---*/
 
-//- function-body
+//- function-has-forbidden-property
-f.caller;
+f.hasOwnProperty("caller")
-//- method-body
+//- method-has-forbidden-property
-this.method.caller;
+this.method.hasOwnProperty("caller")
 //- error
 TypeError

src/function-forms/forbidden-ext-indirect-access-own-prop-caller-get.case

@@ -0,0 +1,34 @@
+// Copyright (C) 2020 Rick Waldron. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+template: forbidden-extensions/bullet-two
+esid: sec-forbidden-extensions
+desc: >
+  Forbidden extension, o.caller
+info: |
+  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.
+
+flags: [noStrict]
+---*/
+
+//- setup
+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;
+}
+//- define-own-caller
+true
+//- define-own-caller-descriptor
+{get(){return 1}}
+//- function-object
+f
+//- method-object
+this.method
+//- error
+TypeError

src/function-forms/forbidden-ext-indirect-access-own-prop-caller-value.case

@@ -0,0 +1,34 @@
+// Copyright (C) 2020 Rick Waldron. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+template: forbidden-extensions/bullet-two
+esid: sec-forbidden-extensions
+desc: >
+  Forbidden extension, o.caller
+info: |
+  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.
+
+flags: [noStrict]
+---*/
+
+//- setup
+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;
+}
+//- define-own-caller
+true
+//- define-own-caller-descriptor
+{value: 1}
+//- function-object
+f
+//- method-object
+this.method
+//- error
+TypeError

src/function-forms/forbidden-ext-indirect-access-prop-caller.case

@@ -6,17 +6,29 @@ esid: sec-forbidden-extensions
 desc: >
   Forbidden extension, o.caller
 info: |
-  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.
 
 flags: [noStrict]
 ---*/
 
 //- setup
+var CALLER_OWN_PROPERTY_DOES_NOT_EXIST = Symbol();
 function inner() {
-  // This property is forbidden from having a value that is strict function object
+  // This property may exist, but is forbidden from having a value that is a strict function object
-  return inner.caller;
+  return inner.hasOwnProperty("caller")
+    ? inner.caller
+    : CALLER_OWN_PROPERTY_DOES_NOT_EXIST;
 }
-//- body
+//- define-own-caller
-inner().toString();
+false
+//- define-own-caller-descriptor
+{}
+//- function-object
+f
+//- method-object
+this.method
 //- error
 TypeError

src/function-forms/forbidden-extensions/bullet-one/arrow-function.template

@@ -6,16 +6,16 @@ name: arrow function expression
 esid: sec-arrow-function-definitions-runtime-semantics-evaluation
 info: |
     ArrowFunction : ArrowParameters => ConciseBody
+features: [arrow-function]
 ---*/
 
 var callCount = 0;
 var f;
 f = (/*{ params }*/) => {
-  /*{ function-body }*/
+  assert.sameValue(/*{ function-has-forbidden-property }*/, false);
   callCount++;
 };
 
-assert.throws(/*{ error }*/, function() {
+
   f(/*{ args }*/);
-});
+assert.sameValue(callCount, 1, 'arrow function body evaluated');
-assert.sameValue(callCount, 0, 'arrow function body not evaluated');

src/function-forms/forbidden-extensions/bullet-one/async-arrow-function.template

@@ -14,21 +14,17 @@ info: |
     { AsyncFunctionBody }
 
 flags: [async]
-features: [async-functions]
+features: [arrow-function, async-functions]
 ---*/
 
 var callCount = 0;
 var f;
 f = async (/*{ params }*/) => {
-  /*{ function-body }*/
+  assert.sameValue(/*{ function-has-forbidden-property }*/, false);
   callCount++;
 };
 
 f(/*{ args }*/)
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-one/async-func-decl.template

@@ -9,20 +9,16 @@ info: |
   AsyncFunctionDeclaration :
     async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody }
 flags: [async]
-features: [async-functions]
+features: [arrow-function, async-functions]
 ---*/
 
 var callCount = 0;
-async function f(/*{ params }*/) {
+async function f() {
-  /*{ function-body }*/
+  assert.sameValue(/*{ function-has-forbidden-property }*/, false);
   callCount++;
 }
 
 f(/*{ args }*/)
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-one/async-func-expr-named.template

@@ -9,20 +9,16 @@ info: |
   AsyncFunctionExpression :
     async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody }
 flags: [async]
-features: [async-functions]
+features: [arrow-function, async-functions]
 ---*/
 
 var callCount = 0;
-var f = async function f(/*{ params }*/) {
+var f = async function f() {
-  /*{ function-body }*/
+  assert.sameValue(/*{ function-has-forbidden-property }*/, false);
   callCount++;
 }
 
 f(/*{ args }*/)
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-one/async-func-expr-nameless.template

@@ -9,20 +9,16 @@ info: |
   AsyncFunctionExpression :
     async function ( FormalParameters ) { AsyncFunctionBody }
 flags: [async]
-features: [async-functions]
+features: [arrow-function, async-functions]
 ---*/
 
 var callCount = 0;
-var f = async function(/*{ params }*/) {
+var f = async function() {
-  /*{ function-body }*/
+  assert.sameValue(/*{ function-has-forbidden-property }*/, false);
   callCount++;
 }
 
 f(/*{ args }*/)
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-one/async-gen-func-decl.template

@@ -9,21 +9,17 @@ info: |
     AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
         ( FormalParameters ) { AsyncGeneratorBody }
 
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration]
 flags: [async]
 ---*/
 
 var callCount = 0;
-async function* f(/*{ params }*/) {
+async function* f() {
-  /*{ function-body }*/
+  assert.sameValue(/*{ function-has-forbidden-property }*/, false);
   callCount++;
 }
 
 f(/*{ args }*/).next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-one/async-gen-func-expr.template

@@ -9,22 +9,18 @@ info: |
     AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
         AsyncGeneratorBody }
 
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration]
 flags: [async]
 ---*/
 
 var callCount = 0;
 var f;
-f = async function*(/*{ params }*/) {
+f = async function*() {
-  /*{ function-body }*/
+  assert.sameValue(/*{ function-has-forbidden-property }*/, false);
   callCount++;
 };
 
 f(/*{ args }*/).next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-one/async-gen-meth.template

@@ -9,23 +9,19 @@ info: |
         async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
             { AsyncGeneratorBody }
 
-features: [async-iteration]
+features: [arrow-function, async-iteration, generators]
 flags: [async]
 ---*/
 
 var callCount = 0;
 var obj = {
-  async *method(/*{ params }*/) {
+  async *method() {
-    /*{ method-body }*/
+    assert.sameValue(/*{ method-has-forbidden-property }*/, false);
     callCount++;
   }
 };
 
 obj.method(/*{ args }*/).next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-one/async-gen-named-func-expr.template

@@ -9,22 +9,18 @@ info: |
     AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
         ( FormalParameters ) { AsyncGeneratorBody }
 
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration]
 flags: [async]
 ---*/
 
 var callCount = 0;
 var f;
-f = async function* g(/*{ params }*/) {
+f = async function* g() {
-  /*{ function-body }*/
+  assert.sameValue(/*{ function-has-forbidden-property }*/, false);
   callCount++;
 };
 
 f(/*{ args }*/).next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-one/async-meth.template

@@ -9,23 +9,19 @@ info: |
   AsyncMethod :
     async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody }
 flags: [async]
-features: [async-functions]
+features: [arrow-function, async-functions]
 ---*/
 
 var callCount = 0;
 
 var obj = {
-  async method(/*{ params }*/) {
+  async method() {
-    /*{ method-body }*/
+    assert.sameValue(/*{ method-has-forbidden-property }*/, false);
     callCount++;
   }
 };
 
 obj.method(/*{ args }*/)
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-one/cls-decl-async-gen-meth-static.template

@@ -7,23 +7,19 @@ name: static class expression generator method
 esid: sec-runtime-semantics-bindingclassdeclarationevaluation
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration, class]
 flags: [async]
 ---*/
 
 var callCount = 0;
 class C {
-  static async *method(/*{ params }*/) {
+  static async *method() {
-    /*{ method-body }*/
+    assert.sameValue(/*{ method-has-forbidden-property }*/, false);
     callCount++;
   }
 }
 
 C.method(/*{ args }*/).next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-one/cls-decl-async-gen-meth.template

@@ -6,23 +6,19 @@ name: class expression method
 esid: sec-class-definitions-runtime-semantics-evaluation
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration, class, generators]
 flags: [async]
 ---*/
 
 var callCount = 0;
 class C {
-  async *method(/*{ params }*/) {
+  async *method() {
-    /*{ method-body }*/
+    assert.sameValue(/*{ method-has-forbidden-property }*/, false);
     callCount++;
   }
 }
 
 C.prototype.method(/*{ args }*/).next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-one/cls-decl-async-meth-static.template

@@ -7,23 +7,19 @@ name: static class declaration async method
 esid: sec-runtime-semantics-bindingclassdeclarationevaluation
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
-features: [async-functions]
+features: [arrow-function, async-functions, async-iteration, class]
 flags: [async]
 ---*/
 
 var callCount = 0;
 class C {
-  static async method(/*{ params }*/) {
+  static async method() {
-    /*{ method-body }*/
+    assert.sameValue(/*{ method-has-forbidden-property }*/, false);
     callCount++;
   }
 }
 
 C.method(/*{ args }*/)
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-one/cls-decl-async-meth.template

@@ -8,22 +8,18 @@ esid: sec-class-definitions-runtime-semantics-evaluation
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
 flags: [async]
-features: [async-functions]
+features: [arrow-function, async-functions, class]
 ---*/
 
 var callCount = 0;
 class C {
-  async method(/*{ params }*/) {
+  async method() {
-    /*{ method-body }*/
+    assert.sameValue(/*{ method-has-forbidden-property }*/, false);
     callCount++;
   }
 }
 
 C.prototype.method(/*{ args }*/)
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-one/cls-decl-gen-meth-static.template

@@ -6,19 +6,17 @@ name: static class expression generator method
 esid: sec-runtime-semantics-bindingclassdeclarationevaluation
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
-features: [generators]
+features: [class, generators]
 ---*/
 
 var callCount = 0;
 class C {
-  static *method(/*{ params }*/) {
+  static *method() {
-    /*{ method-body }*/
+    assert.sameValue(/*{ method-has-forbidden-property }*/, false);
     callCount++;
   }
 }
 
-assert.throws(/*{ error }*/, function() {
 C.method(/*{ args }*/).next();
-});
+assert.sameValue(callCount, 1, 'method body evaluated');
 
-assert.sameValue(callCount, 0, 'method body not evaluated');

src/function-forms/forbidden-extensions/bullet-one/cls-decl-gen-meth.template

@@ -6,18 +6,16 @@ name: class expression method
 esid: sec-class-definitions-runtime-semantics-evaluation
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
-features: [generators]
+features: [class, generators]
 ---*/
 
 var callCount = 0;
 class C {
-  *method(/*{ params }*/) {
+  *method() {
-    /*{ method-body }*/
+    assert.sameValue(/*{ method-has-forbidden-property }*/, false);
     callCount++;
   }
 }
 
-assert.throws(/*{ error }*/, function() {
 C.prototype.method(/*{ args }*/).next();
-});
+assert.sameValue(callCount, 1, 'method body evaluated');
-assert.sameValue(callCount, 0, 'method body not evaluated');

src/function-forms/forbidden-extensions/bullet-one/cls-decl-meth-static.template

@@ -6,17 +6,16 @@ name: static class expression method
 esid: sec-runtime-semantics-bindingclassdeclarationevaluation
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
+features: [class]
 ---*/
 
 var callCount = 0;
 class C {
-  static method(/*{ params }*/) {
+  static method() {
-    /*{ method-body }*/
+    assert.sameValue(/*{ method-has-forbidden-property }*/, false);
     callCount++;
   }
 }
 
-assert.throws(/*{ error }*/, function() {
 C.method(/*{ args }*/);
-});
+assert.sameValue(callCount, 1, 'method body evaluated');
-assert.sameValue(callCount, 0, 'method body not evaluated');

src/function-forms/forbidden-extensions/bullet-one/cls-decl-meth.template

@@ -6,17 +6,16 @@ name: class expression method
 esid: sec-runtime-semantics-bindingclassdeclarationevaluation
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
+features: [class]
 ---*/
 
 var callCount = 0;
 class C {
-  method(/*{ params }*/) {
+  method() {
-    /*{ method-body }*/
+    assert.sameValue(/*{ method-has-forbidden-property }*/, false);
     callCount++;
   }
 }
 
-assert.throws(/*{ error }*/, function() {
 C.prototype.method(/*{ args }*/);
-});
+assert.sameValue(callCount, 1, 'method body evaluated');
-assert.sameValue(callCount, 0, 'method body not evaluated');

src/function-forms/forbidden-extensions/bullet-one/cls-expr-async-gen-meth-static.template

@@ -6,23 +6,19 @@ name: static class expression async generator method
 esid: sec-class-definitions-runtime-semantics-evaluation
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration, class]
 flags: [async]
 ---*/
 
 var callCount = 0;
 var C = class {
-  static async *method(/*{ params }*/) {
+  static async *method() {
-    /*{ method-body }*/
+    assert.sameValue(/*{ method-has-forbidden-property }*/, false);
     callCount++;
   }
 };
 
 C.method(/*{ args }*/).next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-one/cls-expr-async-gen-meth.template

@@ -6,23 +6,19 @@ name: class expression async generator method
 esid: sec-class-definitions-runtime-semantics-evaluation
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration, class]
 flags: [async]
 ---*/
 
 var callCount = 0;
 var C = class {
-  async *method(/*{ params }*/) {
+  async *method() {
-    /*{ method-body }*/
+    assert.sameValue(/*{ method-has-forbidden-property }*/, false);
     callCount++;
   }
 };
 
 C.prototype.method(/*{ args }*/).next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-one/cls-expr-async-meth-static.template

@@ -7,24 +7,20 @@ name: static class expression async method
 esid: sec-class-definitions-runtime-semantics-evaluation
 info: |
   ClassExpression : class BindingIdentifieropt ClassTail
-features: [async-functions]
+features: [arrow-function, async-functions, class]
 flags: [async]
 ---*/
 
 var callCount = 0;
 
 var C = class {
-  static async method(/*{ params }*/) {
+  static async method() {
-    /*{ method-body }*/
+    assert.sameValue(/*{ method-has-forbidden-property }*/, false);
     callCount++;
   }
 };
 
 C.method(/*{ args }*/)
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-one/cls-expr-async-meth.template

@@ -7,23 +7,19 @@ name: class expression async method
 esid: sec-class-definitions-runtime-semantics-evaluation
 info: |
   ClassExpression : class BindingIdentifieropt ClassTail
-features: [async-functions]
+features: [arrow-function, async-functions, class]
 flags: [async]
 ---*/
 
 var callCount = 0;
 var C = class {
-  async method(/*{ params }*/) {
+  async method() {
-    /*{ method-body }*/
+    assert.sameValue(/*{ method-has-forbidden-property }*/, false);
     callCount++;
   }
 };
 
 C.prototype.method(/*{ args }*/)
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-one/cls-expr-gen-meth-static.template

@@ -6,18 +6,16 @@ name: static class expression generator method
 esid: sec-class-definitions-runtime-semantics-evaluation
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
-features: [generators]
+features: [class, generators]
 ---*/
 
 var callCount = 0;
 var C = class {
-  static *method(/*{ params }*/) {
+  static *method() {
-    /*{ method-body }*/
+    assert.sameValue(/*{ method-has-forbidden-property }*/, false);
     callCount++;
   }
 };
 
-assert.throws(/*{ error }*/, function() {
 C.method(/*{ args }*/).next();
-});
+assert.sameValue(callCount, 1, 'method body evaluated');
-assert.sameValue(callCount, 0, 'method body not evaluated');

src/function-forms/forbidden-extensions/bullet-one/cls-expr-gen-meth.template

@@ -6,18 +6,16 @@ name: class expression method
 esid: sec-class-definitions-runtime-semantics-evaluation
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
-features: [generators]
+features: [class, generators]
 ---*/
 
 var callCount = 0;
 var C = class {
-  *method(/*{ params }*/) {
+  *method() {
-    /*{ method-body }*/
+    assert.sameValue(/*{ method-has-forbidden-property }*/, false);
     callCount++;
   }
 };
 
-assert.throws(/*{ error }*/, function() {
 C.prototype.method(/*{ args }*/).next();
-});
+assert.sameValue(callCount, 1, 'method body evaluated');
-assert.sameValue(callCount, 0, 'method body not evaluated');

src/function-forms/forbidden-extensions/bullet-one/cls-expr-meth-static.template

@@ -6,17 +6,16 @@ name: static class expression method
 esid: sec-class-definitions-runtime-semantics-evaluation
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
+features: [class]
 ---*/
 
 var callCount = 0;
 var C = class {
-  static method(/*{ params }*/) {
+  static method() {
-    /*{ method-body }*/
+    assert.sameValue(/*{ method-has-forbidden-property }*/, false);
     callCount++;
   }
 };
 
-assert.throws(/*{ error }*/, function() {
 C.method(/*{ args }*/);
-});
+assert.sameValue(callCount, 1, 'method body evaluated');
-assert.sameValue(callCount, 0, 'method body not evaluated');

src/function-forms/forbidden-extensions/bullet-one/cls-expr-meth.template

@@ -6,17 +6,16 @@ name: class expression method
 esid: sec-class-definitions-runtime-semantics-evaluation
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
+features: [class]
 ---*/
 
 var callCount = 0;
 var C = class {
-  method(/*{ params }*/) {
+  method() {
-    /*{ method-body }*/
+    assert.sameValue(/*{ method-has-forbidden-property }*/, false);
     callCount++;
   }
 };
 
-assert.throws(/*{ error }*/, function() {
 C.prototype.method(/*{ args }*/);
-});
+assert.sameValue(callCount, 1, 'method body evaluated');
-assert.sameValue(callCount, 0, 'method body not evaluated');

src/function-forms/forbidden-extensions/bullet-one/func-decl-strict.template

@@ -10,12 +10,11 @@ info: |
 ---*/
 
 var callCount = 0;
-function f(/*{ params }*/) {
+function f() {
   "use strict";
-  /*{ function-body }*/
+  assert.sameValue(/*{ function-has-forbidden-property }*/, false);
   callCount++;
 }
-assert.throws(/*{ error }*/, function() {
+
 f(/*{ args }*/);
-});
+assert.sameValue(callCount, 1, 'function body evaluated');
-assert.sameValue(callCount, 0, 'function body not evaluated');

src/function-forms/forbidden-extensions/bullet-one/func-decl.template

@@ -1,21 +0,0 @@
-// Copyright (C) 2020 Rick Waldron. All rights reserved.
-// This code is governed by the BSD license found in the LICENSE file.
-/*---
-path: language/statements/function/forbidden-ext/b1/func-decl-
-name: function declaration
-esid: sec-function-definitions-runtime-semantics-instantiatefunctionobject
-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:
----*/
-
-var callCount = 0;
-function f(/*{ params }*/) {
-  /*{ function-body }*/
-  callCount++;
-}
-f(/*{ args }*/);
-assert.sameValue(callCount, 1, 'function was evaluated');

src/function-forms/forbidden-extensions/bullet-one/func-expr-strict.template

@@ -10,12 +10,11 @@ info: |
 
 var callCount = 0;
 var f;
-f = function(/*{ params }*/) {
+f = function() {
   "use strict";
-  /*{ function-body }*/
+  assert.sameValue(/*{ function-has-forbidden-property }*/, false);
   callCount++;
 };
-assert.throws(/*{ error }*/, function() {
+
 f(/*{ args }*/);
-});
+assert.sameValue(callCount, 1, 'function body evaluated');
-assert.sameValue(callCount, 0, 'function body not evaluated');

src/function-forms/forbidden-extensions/bullet-one/func-expr.template

@@ -1,22 +0,0 @@
-// Copyright (C) 2020 Rick Waldron. All rights reserved.
-// This code is governed by the BSD license found in the LICENSE file.
-/*---
-path: language/expressions/function/forbidden-ext/b1/func-expr-
-name: function expression
-esid: sec-function-definitions-runtime-semantics-evaluation
-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:
----*/
-
-var callCount = 0;
-var f;
-f = function(/*{ params }*/) {
-  /*{ function-body }*/
-  callCount++;
-};
-f(/*{ args }*/);
-
-assert.sameValue(callCount, 1, 'function was evaluated');

src/function-forms/forbidden-extensions/bullet-one/gen-func-decl.template

@@ -10,13 +10,11 @@ features: [generators]
 ---*/
 
 var callCount = 0;
-function* f(/*{ params }*/) {
+function* f() {
-  /*{ function-body }*/
+  assert.sameValue(/*{ function-has-forbidden-property }*/, false);
   callCount++;
 }
 
-assert.throws(/*{ error }*/, function() {
 f(/*{ args }*/).next();
-});
+assert.sameValue(callCount, 1, 'generator function body evaluated');
 
-assert.sameValue(callCount, 0, 'generator function body not evaluated');

src/function-forms/forbidden-extensions/bullet-one/gen-func-expr.template

@@ -11,12 +11,11 @@ features: [generators]
 
 var callCount = 0;
 var f;
-f = function*(/*{ params }*/) {
+f = function*() {
-  /*{ function-body }*/
+  assert.sameValue(/*{ function-has-forbidden-property }*/, false);
   callCount++;
 };
 
-assert.throws(/*{ error }*/, function() {
 f(/*{ args }*/).next();
-});
+assert.sameValue(callCount, 1, 'generator function body evaluated');
-assert.sameValue(callCount, 0, 'generator function body not evaluated');
+

src/function-forms/forbidden-extensions/bullet-one/gen-meth.template

@@ -13,13 +13,11 @@ features: [generators]
 
 var callCount = 0;
 var obj = {
-  *method(/*{ params }*/) {
+  *method() {
-    /*{ method-body }*/
+    assert.sameValue(/*{ method-has-forbidden-property }*/, false);
     callCount++;
   }
 };
 
-assert.throws(/*{ error }*/, function() {
 obj.method(/*{ args }*/).next();
-});
+assert.sameValue(callCount, 1, 'generator method body evaluated');
-assert.sameValue(callCount, 0, 'generator method body not evaluated');

src/function-forms/forbidden-extensions/bullet-one/meth.template

@@ -10,13 +10,11 @@ info: |
 
 var callCount = 0;
 var obj = {
-  method(/*{ params }*/) {
+  method() {
-    /*{ method-body }*/
+    assert.sameValue(/*{ method-has-forbidden-property }*/, false);
     callCount++;
   }
 };
 
-assert.throws(/*{ error }*/, function() {
 obj.method(/*{ args }*/);
-});
+assert.sameValue(callCount, 1, 'method body evaluated');
-assert.sameValue(callCount, 0, 'method body not evaluated');

src/function-forms/forbidden-extensions/bullet-two/arrow-function.template

@@ -6,17 +6,40 @@ name: arrow function expression
 esid: sec-arrow-definitions-runtime-semantics-evaluation
 info: |
     ArrowFunction : ArrowParameters => ConciseBody
+features: [arrow-function]
 ---*/
 
 var callCount = 0;
 var f;
 f = (/*{ params }*/) => {
   "use strict";
-  /*{ body }*/
+  // 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 && /*{ define-own-caller }*/) {
+    Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+    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, /*{ function-object }*/);
+  }
   callCount++;
 };
 
-assert.throws(/*{ error }*/, function() {
 f(/*{ args }*/);
-});
+assert.sameValue(callCount, 1, 'arrow function body evaluated');
-assert.sameValue(callCount, 0, 'arrow function body not evaluated');

src/function-forms/forbidden-extensions/bullet-two/async-arrow-function.template

@@ -14,22 +14,42 @@ info: |
     { AsyncFunctionBody }
 
 flags: [async]
-features: [async-functions]
+features: [arrow-function, async-functions]
 ---*/
 
 var callCount = 0;
 var f;
 f = async (/*{ params }*/) => {
   "use strict";
-  /*{ body }*/
+  // 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 && /*{ define-own-caller }*/) {
+    Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+    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, /*{ function-object }*/);
+  }
   callCount++;
 };
 
 f(/*{ args }*/)
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-two/async-func-decl.template

@@ -9,21 +9,41 @@ info: |
   AsyncFunctionDeclaration :
     async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody }
 flags: [async]
-features: [async-functions]
+features: [arrow-function, async-functions]
 ---*/
 
 var callCount = 0;
-async function f(/*{ params }*/) {
+async function f() {
   "use strict";
-  /*{ body }*/
+  // 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 && /*{ define-own-caller }*/) {
+    Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+    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, /*{ function-object }*/);
+  }
   callCount++;
 }
 
 f(/*{ args }*/)
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-two/async-func-expr-named.template

@@ -9,21 +9,42 @@ info: |
   AsyncFunctionExpression :
     async function BindingIdentifier ( FormalParameters ) { AsyncFunctionBody }
 flags: [async]
-features: [async-functions]
+features: [arrow-function, async-functions]
 ---*/
 
 var callCount = 0;
-var f = async function f(/*{ params }*/) {
+var f;
+f = async function f() {
   "use strict";
-  /*{ body }*/
+  // 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 && /*{ define-own-caller }*/) {
+    Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+    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, /*{ function-object }*/);
+  }
   callCount++;
 }
 
 f(/*{ args }*/)
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-two/async-func-expr-nameless.template

@@ -9,21 +9,42 @@ info: |
   AsyncFunctionExpression :
     async function ( FormalParameters ) { AsyncFunctionBody }
 flags: [async]
-features: [async-functions]
+features: [arrow-function, async-functions]
 ---*/
 
 var callCount = 0;
-var f = async function(/*{ params }*/) {
+var f;
+f = async function() {
   "use strict";
-  /*{ body }*/
+  // 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 && /*{ define-own-caller }*/) {
+    Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+    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, /*{ function-object }*/);
+  }
   callCount++;
 }
 
 f(/*{ args }*/)
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-two/async-gen-func-decl.template

@@ -9,22 +9,42 @@ info: |
     AsyncGeneratorDeclaration : async [no LineTerminator here] function * BindingIdentifier
         ( FormalParameters ) { AsyncGeneratorBody }
 
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration]
 flags: [async]
 ---*/
 
 var callCount = 0;
-async function* f(/*{ params }*/) {
+async function* f() {
   "use strict";
-  /*{ body }*/
+  // 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 && /*{ define-own-caller }*/) {
+    Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+    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, /*{ function-object }*/);
+  }
   callCount++;
 }
 
 f(/*{ args }*/).next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-two/async-gen-func-expr.template

@@ -9,23 +9,43 @@ info: |
     AsyncGeneratorExpression : async [no LineTerminator here] function * ( FormalParameters ) {
         AsyncGeneratorBody }
 
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration]
 flags: [async]
 ---*/
 
 var callCount = 0;
 var f;
-f = async function*(/*{ params }*/) {
+f = async function*() {
   "use strict";
-  /*{ body }*/
+  // 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 && /*{ define-own-caller }*/) {
+    Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+    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, /*{ function-object }*/);
+  }
   callCount++;
 };
 
 f(/*{ args }*/).next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-two/async-gen-meth.template

@@ -9,24 +9,44 @@ info: |
         async [no LineTerminator here] * PropertyName ( UniqueFormalParameters )
             { AsyncGeneratorBody }
 
-features: [async-iteration]
+features: [arrow-function, async-iteration, generators]
 flags: [async]
 ---*/
 
 var callCount = 0;
 var obj = {
-  async *method(/*{ params }*/) {
+  async *method() {
     "use strict";
-    /*{ body }*/
+    // 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 && /*{ define-own-caller }*/) {
+      Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+      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, /*{ method-object }*/);
+    }
     callCount++;
   }
 };
 
 obj.method(/*{ args }*/).next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-two/async-gen-named-func-expr.template

@@ -9,23 +9,43 @@ info: |
     AsyncGeneratorExpression : async [no LineTerminator here] function * BindingIdentifier
         ( FormalParameters ) { AsyncGeneratorBody }
 
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration]
 flags: [async]
 ---*/
 
 var callCount = 0;
 var f;
-f = async function* g(/*{ params }*/) {
+f = async function* g() {
   "use strict";
-  /*{ body }*/
+  // 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 && /*{ define-own-caller }*/) {
+    Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+    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, /*{ function-object }*/);
+  }
   callCount++;
 };
 
 f(/*{ args }*/).next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-two/async-meth.template

@@ -9,24 +9,44 @@ info: |
   AsyncMethod :
    async PropertyName ( UniqueFormalParameters ) { AsyncFunctionBody }
 flags: [async]
-features: [async-functions]
+features: [arrow-function, async-functions]
 ---*/
 
 var callCount = 0;
 
 var obj = {
-  async method(/*{ params }*/) {
+  async method() {
     "use strict";
-    /*{ body }*/
+    // 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 && /*{ define-own-caller }*/) {
+      Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+      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, /*{ method-object }*/);
+    }
     callCount++;
   }
 };
 
 obj.method(/*{ args }*/)
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-two/cls-decl-async-gen-meth-static.template

@@ -7,24 +7,44 @@ name: static class expression generator method
 esid: sec-runtime-semantics-bindingclassdeclarationevaluation
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration, class]
 flags: [async]
 ---*/
 
 var callCount = 0;
 class C {
-  static async *method(/*{ params }*/) {
+  static async *method() {
     /* implicit strict */
-    /*{ body }*/
+    // 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 && /*{ define-own-caller }*/) {
+      Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+      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, /*{ method-object }*/);
+    }
     callCount++;
   }
 }
 
 C.method(/*{ args }*/).next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-two/cls-decl-async-gen-meth.template

@@ -6,24 +6,44 @@ name: class expression method
 esid: sec-class-definitions-runtime-semantics-evaluation
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration, class]
 flags: [async]
 ---*/
 
 var callCount = 0;
 class C {
-  async *method(/*{ params }*/) {
+  async *method() {
     /* implicit strict */
-    /*{ body }*/
+    // 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 && /*{ define-own-caller }*/) {
+      Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+      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, /*{ method-object }*/);
+    }
     callCount++;
   }
 }
 
 C.prototype.method(/*{ args }*/).next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-two/cls-decl-async-meth-static.template

@@ -7,24 +7,44 @@ name: static class declaration async method
 esid: sec-runtime-semantics-bindingclassdeclarationevaluation
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
-features: [async-functions]
+features: [arrow-function, async-functions, class]
 flags: [async]
 ---*/
 
 var callCount = 0;
 class C {
-  static async method(/*{ params }*/) {
+  static async method() {
     /* implicit strict */
-    /*{ body }*/
+    // 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 && /*{ define-own-caller }*/) {
+      Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+      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, /*{ method-object }*/);
+    }
     callCount++;
   }
 }
 
 C.method(/*{ args }*/)
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-two/cls-decl-async-meth.template

@@ -8,23 +8,43 @@ esid: sec-class-definitions-runtime-semantics-evaluation
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
 flags: [async]
-features: [async-functions]
+features: [arrow-function, async-functions, class]
 ---*/
 
 var callCount = 0;
 class C {
-  async method(/*{ params }*/) {
+  async method() {
     /* implicit strict */
-    /*{ body }*/
+    // 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 && /*{ define-own-caller }*/) {
+      Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+      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, /*{ method-object }*/);
+    }
     callCount++;
   }
 }
 
 C.prototype.method(/*{ args }*/)
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-two/cls-decl-gen-meth-static.template

@@ -6,20 +6,42 @@ name: static class expression generator method
 esid: sec-runtime-semantics-bindingclassdeclarationevaluation
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
-features: [generators]
+features: [class, generators]
 ---*/
 
 var callCount = 0;
 class C {
-  static *method(/*{ params }*/) {
+  static *method() {
     /* implicit strict */
-    /*{ body }*/
+    // 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 && /*{ define-own-caller }*/) {
+      Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+      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, /*{ method-object }*/);
+    }
     callCount++;
   }
 }
 
-assert.throws(/*{ error }*/, function() {
 C.method(/*{ args }*/).next();
-});
 
-assert.sameValue(callCount, 0, 'method body not evaluated');
+assert.sameValue(callCount, 1, 'method body evaluated');

src/function-forms/forbidden-extensions/bullet-two/cls-decl-gen-meth.template

@@ -6,19 +6,41 @@ name: class expression method
 esid: sec-class-definitions-runtime-semantics-evaluation
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
-features: [generators]
+features: [class, generators]
 ---*/
 
 var callCount = 0;
 class C {
-  *method(/*{ params }*/) {
+  *method() {
     /* implicit strict */
-    /*{ body }*/
+    // 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 && /*{ define-own-caller }*/) {
+      Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+      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, /*{ method-object }*/);
+    }
     callCount++;
   }
 }
 
-assert.throws(/*{ error }*/, function() {
 C.prototype.method(/*{ args }*/).next();
-});
+assert.sameValue(callCount, 1, 'method body evaluated');
-assert.sameValue(callCount, 0, 'method body not evaluated');

src/function-forms/forbidden-extensions/bullet-two/cls-decl-meth-static.template

@@ -6,18 +6,41 @@ name: static class expression method
 esid: sec-runtime-semantics-bindingclassdeclarationevaluation
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
+features: [class]
 ---*/
 
 var callCount = 0;
 class C {
-  static method(/*{ params }*/) {
+  static method() {
     /* implicit strict */
-    /*{ body }*/
+    // 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 && /*{ define-own-caller }*/) {
+      Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+      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, /*{ method-object }*/);
+    }
     callCount++;
   }
 }
 
-assert.throws(/*{ error }*/, function() {
 C.method(/*{ args }*/);
-});
+assert.sameValue(callCount, 1, 'method body evaluated');
-assert.sameValue(callCount, 0, 'method body not evaluated');

src/function-forms/forbidden-extensions/bullet-two/cls-decl-meth.template

@@ -6,18 +6,41 @@ name: class expression method
 esid: sec-runtime-semantics-bindingclassdeclarationevaluation
 info: |
     ClassDeclaration : class BindingIdentifier ClassTail
+features: [class]
 ---*/
 
 var callCount = 0;
 class C {
-  method(/*{ params }*/) {
+  method() {
     /* implicit strict */
-    /*{ body }*/
+    // 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 && /*{ define-own-caller }*/) {
+      Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+      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, /*{ method-object }*/);
+    }
     callCount++;
   }
 }
 
-assert.throws(/*{ error }*/, function() {
 C.prototype.method(/*{ args }*/);
-});
+assert.sameValue(callCount, 1, 'method body evaluated');
-assert.sameValue(callCount, 0, 'method body not evaluated');

src/function-forms/forbidden-extensions/bullet-two/cls-expr-async-gen-meth-static.template

@@ -6,24 +6,44 @@ name: static class expression async generator method
 esid: sec-class-definitions-runtime-semantics-evaluation
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration, class]
 flags: [async]
 ---*/
 
 var callCount = 0;
 var C = class {
-  static async *method(/*{ params }*/) {
+  static async *method() {
     /* implicit strict */
-    /*{ body }*/
+    // 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 && /*{ define-own-caller }*/) {
+      Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+      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, /*{ method-object }*/);
+    }
     callCount++;
   }
 };
 
 C.method(/*{ args }*/).next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-two/cls-expr-async-gen-meth.template

@@ -6,24 +6,44 @@ name: class expression async generator method
 esid: sec-class-definitions-runtime-semantics-evaluation
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
-features: [async-iteration]
+features: [arrow-function, async-functions, async-iteration, class]
 flags: [async]
 ---*/
 
 var callCount = 0;
 var C = class {
-  async *method(/*{ params }*/) {
+  async *method() {
     /* implicit strict */
-    /*{ body }*/
+    // 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 && /*{ define-own-caller }*/) {
+      Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+      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, /*{ method-object }*/);
+    }
     callCount++;
   }
 };
 
 C.prototype.method(/*{ args }*/).next()
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-two/cls-expr-async-meth-static.template

@@ -7,25 +7,45 @@ name: static class expression async method
 esid: sec-class-definitions-runtime-semantics-evaluation
 info: |
   ClassExpression : class BindingIdentifieropt ClassTail
-features: [async-functions]
+features: [arrow-function, async-functions, class]
 flags: [async]
 ---*/
 
 var callCount = 0;
 
 var C = class {
-  static async method(/*{ params }*/) {
+  static async method() {
     /* implicit strict */
-    /*{ body }*/
+    // 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 && /*{ define-own-caller }*/) {
+      Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+      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, /*{ method-object }*/);
+    }
     callCount++;
   }
 };
 
 C.method(/*{ args }*/)
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-two/cls-expr-async-meth.template

@@ -7,24 +7,44 @@ name: class expression async method
 esid: sec-class-definitions-runtime-semantics-evaluation
 info: |
   ClassExpression : class BindingIdentifieropt ClassTail
-features: [async-functions]
+features: [arrow-function, async-functions, class]
 flags: [async]
 ---*/
 
 var callCount = 0;
 var C = class {
-  async method(/*{ params }*/) {
+  async method() {
     /* implicit strict */
-    /*{ body }*/
+    // 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 && /*{ define-own-caller }*/) {
+      Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+      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, /*{ method-object }*/);
+    }
     callCount++;
   }
 };
 
 C.prototype.method(/*{ args }*/)
-  .then(_ => {
-    throw new Test262Error('function should not be resolved');
-  }, error => assert.sameValue(error.constructor, /*{ error }*/))
   .then(() => {
-    assert.sameValue(callCount, 0, 'function body is not evaluated');
+    assert.sameValue(callCount, 1, 'function body evaluated');
-  }, $DONE)
+  }, $DONE).then($DONE, $DONE);
-  .then($DONE, $DONE);

src/function-forms/forbidden-extensions/bullet-two/cls-expr-gen-meth-static.template

@@ -6,19 +6,41 @@ name: static class expression generator method
 esid: sec-class-definitions-runtime-semantics-evaluation
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
-features: [generators]
+features: [class, generators]
 ---*/
 
 var callCount = 0;
 var C = class {
-  static *method(/*{ params }*/) {
+  static *method() {
     /* implicit strict */
-    /*{ body }*/
+    // 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 && /*{ define-own-caller }*/) {
+      Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+      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, /*{ method-object }*/);
+    }
     callCount++;
   }
 };
 
-assert.throws(/*{ error }*/, function() {
 C.method(/*{ args }*/).next();
-});
+assert.sameValue(callCount, 1, 'method body evaluated');
-assert.sameValue(callCount, 0, 'method body not evaluated');

src/function-forms/forbidden-extensions/bullet-two/cls-expr-gen-meth.template

@@ -6,19 +6,42 @@ name: class expression method
 esid: sec-class-definitions-runtime-semantics-evaluation
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
-features: [generators]
+features: [class, generators]
 ---*/
 
 var callCount = 0;
 var C = class {
-  *method(/*{ params }*/) {
+  *method() {
     /* implicit strict */
-    /*{ body }*/
+    // 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 && /*{ define-own-caller }*/) {
+      Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+      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, /*{ method-object }*/);
+    }
+
     callCount++;
   }
 };
 
-assert.throws(/*{ error }*/, function() {
 C.prototype.method(/*{ args }*/).next();
-});
+assert.sameValue(callCount, 1, 'method body evaluated');
-assert.sameValue(callCount, 0, 'method body not evaluated');

src/function-forms/forbidden-extensions/bullet-two/cls-expr-meth-static.template

@@ -6,18 +6,42 @@ name: static class expression method
 esid: sec-class-definitions-runtime-semantics-evaluation
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
+features: [class]
 ---*/
 
 var callCount = 0;
 var C = class {
-  static method(/*{ params }*/) {
+  static method() {
     /* implicit strict */
-    /*{ body }*/
+    // 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 && /*{ define-own-caller }*/) {
+      Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+      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, /*{ method-object }*/);
+    }
+
     callCount++;
   }
 };
 
-assert.throws(/*{ error }*/, function() {
 C.method(/*{ args }*/);
-});
+assert.sameValue(callCount, 1, 'method body evaluated');
-assert.sameValue(callCount, 0, 'method body not evaluated');

src/function-forms/forbidden-extensions/bullet-two/cls-expr-meth.template

@@ -6,18 +6,42 @@ name: class expression method
 esid: sec-class-definitions-runtime-semantics-evaluation
 info: |
     ClassExpression : class BindingIdentifieropt ClassTail
+features: [class]
 ---*/
 
 var callCount = 0;
 var C = class {
-  method(/*{ params }*/) {
+  method() {
     /* implicit strict */
-    /*{ body }*/
+    // 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 && /*{ define-own-caller }*/) {
+      Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+      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, /*{ method-object }*/);
+    }
+
     callCount++;
   }
 };
 
-assert.throws(/*{ error }*/, function() {
 C.prototype.method(/*{ args }*/);
-});
+assert.sameValue(callCount, 1, 'method body evaluated');
-assert.sameValue(callCount, 0, 'method body not evaluated');

src/function-forms/forbidden-extensions/bullet-two/func-decl.template

@@ -10,12 +10,36 @@ info: |
 ---*/
 
 var callCount = 0;
-function f(/*{ params }*/) {
+function f() {
   "use strict";
-  /*{ body }*/
+  // 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 && /*{ define-own-caller }*/) {
+    Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+    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, /*{ function-object }*/);
+  }
+
   callCount++;
 }
-assert.throws(/*{ error }*/, function() {
 f(/*{ args }*/);
-});
+assert.sameValue(callCount, 1, 'body evaluated');
-assert.sameValue(callCount, 0, 'method body not evaluated');

src/function-forms/forbidden-extensions/bullet-two/func-expr.template

@@ -10,12 +10,36 @@ info: |
 
 var callCount = 0;
 var f;
-f = function(/*{ params }*/) {
+f = function() {
   "use strict";
-  /*{ body }*/
+  // 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 && /*{ define-own-caller }*/) {
+    Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+    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, /*{ function-object }*/);
+  }
+
   callCount++;
 };
-assert.throws(/*{ error }*/, function() {
 f(/*{ args }*/);
-});
+assert.sameValue(callCount, 1, 'body evaluated');
-assert.sameValue(callCount, 0, 'method body not evaluated');

src/function-forms/forbidden-extensions/bullet-two/gen-func-decl.template

@@ -10,14 +10,38 @@ features: [generators]
 ---*/
 
 var callCount = 0;
-function* f(/*{ params }*/) {
+function* f() {
   "use strict";
-  /*{ body }*/
+  // 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 && /*{ define-own-caller }*/) {
+    Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+    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, /*{ function-object }*/);
+  }
+
   callCount++;
 }
 
-assert.throws(/*{ error }*/, function() {
 f(/*{ args }*/).next();
-});
 
-assert.sameValue(callCount, 0, 'generator function body not evaluated');
+assert.sameValue(callCount, 1, 'generator function body evaluated');

src/function-forms/forbidden-extensions/bullet-two/gen-func-expr.template

@@ -11,13 +11,37 @@ features: [generators]
 
 var callCount = 0;
 var f;
-f = function*(/*{ params }*/) {
+f = function*() {
   "use strict";
-  /*{ body }*/
+  // 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 && /*{ define-own-caller }*/) {
+    Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+  }
+  var result = inner();
+  if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+    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, /*{ function-object }*/);
+  }
+
   callCount++;
 };
 
-assert.throws(/*{ error }*/, function() {
 f(/*{ args }*/).next();
-});
+assert.sameValue(callCount, 1, 'generator function body evaluated');
-assert.sameValue(callCount, 0, 'generator function body not evaluated');

src/function-forms/forbidden-extensions/bullet-two/gen-meth.template

@@ -13,14 +13,36 @@ features: [generators]
 
 var callCount = 0;
 var obj = {
-  *method(/*{ params }*/) {
+  *method() {
     "use strict";
-    /*{ body }*/
+    // 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 && /*{ define-own-caller }*/) {
+      Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+      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, /*{ method-object }*/);
+    }
     callCount++;
   }
 };
 
-assert.throws(/*{ error }*/, function() {
+obj.method(/*{ args }*/).next().value;
-  obj.method(/*{ args }*/).next();
+assert.sameValue(callCount, 1, 'generator method body was evaluated');
-});
-assert.sameValue(callCount, 0, 'generator method body not evaluated');

src/function-forms/forbidden-extensions/bullet-two/meth.template

@@ -10,14 +10,37 @@ info: |
 
 var callCount = 0;
 var obj = {
-  method(/*{ params }*/) {
+  method() {
     "use strict";
-    /*{ body }*/
+    // 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 && /*{ define-own-caller }*/) {
+      Object.defineProperty(inner, "caller", /*{ define-own-caller-descriptor }*/);
+    }
+    var result = inner();
+    if (descriptor && descriptor.configurable && /*{ define-own-caller }*/) {
+      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, /*{ method-object }*/);
+    }
+
     callCount++;
   }
 };
 
-assert.throws(/*{ error }*/, function() {
 obj.method(/*{ args }*/);
-});
+assert.sameValue(callCount, 1, 'method body evaluated');
-assert.sameValue(callCount, 0, 'method body not evaluated');