diff --git a/src/async-generators/default/async-class-decl-method.template b/src/async-generators/default/async-class-decl-method.template
new file mode 100644
index 0000000000000000000000000000000000000000..87cd550d46a039bc396b9bdd31ba7ea620ca9856
--- /dev/null
+++ b/src/async-generators/default/async-class-decl-method.template
@@ -0,0 +1,35 @@
+// Copyright (C) 2017 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/statements/class/async-gen-method-
+name: Async Generator method as a ClassDeclaration element
+esid: prod-AsyncGeneratorMethod
+info: |
+  ClassElement :
+    MethodDefinition
+
+  MethodDefinition :
+    AsyncGeneratorMethod
+
+  Async Generator Function Definitions
+
+  AsyncGeneratorMethod :
+    async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+features: [async-iteration]
+---*/
+
+var callCount = 0;
+
+class C { async *gen() {
+    callCount += 1;
+    /*{ body }*/
+}}
+
+var gen = C.prototype.gen;
+
+var iter = gen();
+
+/*{ assertions }*/
+
+assert.sameValue(callCount, 1);
diff --git a/src/async-generators/default/async-class-decl-static-method.template b/src/async-generators/default/async-class-decl-static-method.template
new file mode 100644
index 0000000000000000000000000000000000000000..00b105ad4329305ab73d35b71e4728a2b942b75c
--- /dev/null
+++ b/src/async-generators/default/async-class-decl-static-method.template
@@ -0,0 +1,35 @@
+// Copyright (C) 2017 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/statements/class/async-gen-method-static-
+name: Static async generator method as a ClassDeclaration element
+esid: prod-AsyncGeneratorMethod
+info: |
+  ClassElement :
+    static MethodDefinition
+
+  MethodDefinition :
+    AsyncGeneratorMethod
+
+  Async Generator Function Definitions
+
+  AsyncGeneratorMethod :
+    async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+features: [async-iteration]
+---*/
+
+var callCount = 0;
+
+class C { static async *gen() {
+    callCount += 1;
+    /*{ body }*/
+}}
+
+var gen = C.gen;
+
+var iter = gen();
+
+/*{ assertions }*/
+
+assert.sameValue(callCount, 1);
diff --git a/src/async-generators/default/async-class-expr-method.template b/src/async-generators/default/async-class-expr-method.template
new file mode 100644
index 0000000000000000000000000000000000000000..745a8e92792c49ad832f050aba1c96fc171af588
--- /dev/null
+++ b/src/async-generators/default/async-class-expr-method.template
@@ -0,0 +1,35 @@
+// Copyright (C) 2017 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/expressions/class/async-gen-method-
+name: Async generator method as a ClassExpression element
+esid: prod-AsyncGeneratorMethod
+info: |
+  ClassElement :
+    MethodDefinition
+
+  MethodDefinition :
+    AsyncGeneratorMethod
+
+  Async Generator Function Definitions
+
+  AsyncGeneratorMethod :
+    async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+features: [async-iteration]
+---*/
+
+var callCount = 0;
+
+var C = class { async *gen() {
+    callCount += 1;
+    /*{ body }*/
+}}
+
+var gen = C.prototype.gen;
+
+var iter = gen();
+
+/*{ assertions }*/
+
+assert.sameValue(callCount, 1);
diff --git a/src/async-generators/default/async-class-expr-static-method.template b/src/async-generators/default/async-class-expr-static-method.template
new file mode 100644
index 0000000000000000000000000000000000000000..ac7328fff2754f5eae3054927de00500c02d6ccc
--- /dev/null
+++ b/src/async-generators/default/async-class-expr-static-method.template
@@ -0,0 +1,35 @@
+// Copyright (C) 2017 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/expressions/class/async-gen-method-static-
+name: Static async generator method as a ClassExpression element
+esid: prod-AsyncGeneratorMethod
+info: |
+  ClassElement :
+    static MethodDefinition
+
+  MethodDefinition :
+    AsyncGeneratorMethod
+
+  Async Generator Function Definitions
+
+  AsyncGeneratorMethod :
+    async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+features: [async-iteration]
+---*/
+
+var callCount = 0;
+
+var C = class { static async *gen() {
+    callCount += 1;
+    /*{ body }*/
+}}
+
+var gen = C.gen;
+
+var iter = gen();
+
+/*{ assertions }*/
+
+assert.sameValue(callCount, 1);
diff --git a/src/async-generators/default/async-declaration.template b/src/async-generators/default/async-declaration.template
new file mode 100644
index 0000000000000000000000000000000000000000..c32db4e674bf6148fd6e5f4872e084fe638780b3
--- /dev/null
+++ b/src/async-generators/default/async-declaration.template
@@ -0,0 +1,28 @@
+// Copyright (C) 2017 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/statements/async-generator/
+name: Async generator Function declaration
+esid: prod-AsyncGeneratorDeclaration
+info: |
+  Async Generator Function Definitions
+
+  AsyncGeneratorDeclaration:
+    async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
+      AsyncGeneratorBody }
+features: [async-iteration]
+---*/
+
+var callCount = 0;
+
+async function *gen() {
+  callCount += 1;
+  /*{ body }*/
+}
+
+var iter = gen();
+
+/*{ assertions }*/
+
+assert.sameValue(callCount, 1);
diff --git a/src/async-generators/default/async-expression-named.template b/src/async-generators/default/async-expression-named.template
new file mode 100644
index 0000000000000000000000000000000000000000..e02b6938bb54e128af58e5d87258be48fa897be7
--- /dev/null
+++ b/src/async-generators/default/async-expression-named.template
@@ -0,0 +1,28 @@
+// Copyright (C) 2017 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/expressions/async-generator/named-
+name: Named async generator expression
+esid: prod-AsyncGeneratorExpression
+info: |
+  Async Generator Function Definitions
+
+  AsyncGeneratorExpression :
+    async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
+      AsyncGeneratorBody }
+features: [async-iteration]
+---*/
+
+var callCount = 0;
+
+var gen = async function *g() {
+  callCount += 1;
+  /*{ body }*/
+};
+
+var iter = gen();
+
+/*{ assertions }*/
+
+assert.sameValue(callCount, 1);
diff --git a/src/async-generators/default/async-expression.template b/src/async-generators/default/async-expression.template
new file mode 100644
index 0000000000000000000000000000000000000000..11e0b0a9626e8c99dffb52cfb322a497bf02515d
--- /dev/null
+++ b/src/async-generators/default/async-expression.template
@@ -0,0 +1,28 @@
+// Copyright (C) 2017 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/expressions/async-generator/
+name: Unnamed async generator expression
+esid: prod-AsyncGeneratorExpression
+info: |
+  Async Generator Function Definitions
+
+  AsyncGeneratorExpression :
+    async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
+      AsyncGeneratorBody }
+features: [async-iteration]
+---*/
+
+var callCount = 0;
+
+var gen = async function *() {
+  callCount += 1;
+  /*{ body }*/
+};
+
+var iter = gen();
+
+/*{ assertions }*/
+
+assert.sameValue(callCount, 1);
diff --git a/src/async-generators/default/async-obj-method.template b/src/async-generators/default/async-obj-method.template
new file mode 100644
index 0000000000000000000000000000000000000000..c9e64d90c6a30c553882d2d030976766dec9be7d
--- /dev/null
+++ b/src/async-generators/default/async-obj-method.template
@@ -0,0 +1,28 @@
+// Copyright (C) 2017 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/object/method-definition/async-gen-
+name: Async generator method
+esid: prod-AsyncGeneratorMethod
+info: |
+  Async Generator Function Definitions
+
+  AsyncGeneratorMethod :
+    async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+features: [async-iteration]
+---*/
+
+var callCount = 0;
+
+var gen = {
+  async *method() {
+    callCount += 1;
+    /*{ body }*/
+  }
+}.method;
+
+var iter = gen();
+
+/*{ assertions }*/
+
+assert.sameValue(callCount, 1);
diff --git a/src/async-generators/non-strict/async-declaration.template b/src/async-generators/non-strict/async-declaration.template
new file mode 100644
index 0000000000000000000000000000000000000000..7baa44f5adecef9cd37db3dd43d5028dda6bb013
--- /dev/null
+++ b/src/async-generators/non-strict/async-declaration.template
@@ -0,0 +1,28 @@
+// Copyright (C) 2017 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/statements/async-generator/
+name: Async generator function declaration - valid for non-strict only cases
+esid: prod-AsyncGeneratorDeclaration
+info: |
+  Async Generator Function Definitions
+
+  AsyncGeneratorDeclaration:
+    async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
+      AsyncGeneratorBody }
+features: [async-iteration]
+---*/
+
+var callCount = 0;
+
+async function *gen() {
+  callCount += 1;
+  /*{ body }*/
+}
+
+var iter = gen();
+
+/*{ assertions }*/
+
+assert.sameValue(callCount, 1);
diff --git a/src/async-generators/non-strict/async-expression-named.template b/src/async-generators/non-strict/async-expression-named.template
new file mode 100644
index 0000000000000000000000000000000000000000..0659f18886975b3ffb69b27d3b34bd3804cda675
--- /dev/null
+++ b/src/async-generators/non-strict/async-expression-named.template
@@ -0,0 +1,28 @@
+// Copyright (C) 2017 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/expressions/async-generator/named-
+name: Async generator named expression - valid for non-strict only cases
+esid: prod-AsyncGeneratorExpression
+info: |
+  Async Generator Function Definitions
+
+  AsyncGeneratorExpression :
+    async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
+      AsyncGeneratorBody }
+features: [async-iteration]
+---*/
+
+var callCount = 0;
+
+var gen = async function *g() {
+  callCount += 1;
+  /*{ body }*/
+};
+
+var iter = gen();
+
+/*{ assertions }*/
+
+assert.sameValue(callCount, 1);
diff --git a/src/async-generators/non-strict/async-expression.template b/src/async-generators/non-strict/async-expression.template
new file mode 100644
index 0000000000000000000000000000000000000000..20d3bc841f0944e5a6626583665776cafa4d7794
--- /dev/null
+++ b/src/async-generators/non-strict/async-expression.template
@@ -0,0 +1,28 @@
+// Copyright (C) 2017 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/expressions/async-generator/
+name: Async generator expression - valid for non-strict only cases
+esid: prod-AsyncGeneratorExpression
+info: |
+  Async Generator Function Definitions
+
+  AsyncGeneratorExpression :
+    async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
+      AsyncGeneratorBody }
+features: [async-iteration]
+---*/
+
+var callCount = 0;
+
+var gen = async function *() {
+  callCount += 1;
+  /*{ body }*/
+};
+
+var iter = gen();
+
+/*{ assertions }*/
+
+assert.sameValue(callCount, 1);
diff --git a/src/async-generators/non-strict/async-obj-method.template b/src/async-generators/non-strict/async-obj-method.template
new file mode 100644
index 0000000000000000000000000000000000000000..b15e9da3cd352728792ee24d28954e9092392f66
--- /dev/null
+++ b/src/async-generators/non-strict/async-obj-method.template
@@ -0,0 +1,29 @@
+// Copyright (C) 2017 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+path: language/expressions/object/method-definition/async-gen-
+name: Generator method - valid for non-strict only cases
+esid: prod-AsyncGeneratorMethod
+info: |
+  Async Generator Function Definitions
+
+  AsyncGeneratorMethod :
+    async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+features: [async-iteration]
+---*/
+
+var callCount = 0;
+
+var gen = {
+  async *method() {
+    callCount += 1;
+    /*{ body }*/
+  }
+}.method;
+
+var iter = gen();
+
+/*{ assertions }*/
+
+assert.sameValue(callCount, 1);
diff --git a/src/async-generators/yield-identifier-non-strict.case b/src/async-generators/yield-identifier-non-strict.case
new file mode 100644
index 0000000000000000000000000000000000000000..ebbcb1add8364e29afdcea5f96912ac46c27dce8
--- /dev/null
+++ b/src/async-generators/yield-identifier-non-strict.case
@@ -0,0 +1,30 @@
+// Copyright (C) 2017 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+desc: >
+  Use of yield as a valid identifier in a function body inside a generator body
+  in non strict mode
+template: non-strict
+flags: [noStrict, async]
+---*/
+
+//- body
+  return (function(arg) {
+    var yield = arg + 1;
+    return yield;
+  }(yield))
+//- assertions
+var item = iter.next();
+
+item.then(({ done, value }) => {
+  assert.sameValue(done, false);
+  assert.sameValue(value, undefined);
+});
+
+item = iter.next(42);
+
+item.then(({ done, value }) => {
+  assert.sameValue(done, true);
+  assert.sameValue(value, 43);
+}).then($DONE, $DONE);
diff --git a/src/async-generators/yield-identifier-spread-non-strict.case b/src/async-generators/yield-identifier-spread-non-strict.case
new file mode 100644
index 0000000000000000000000000000000000000000..0db9d527dfe829d5be5c739569e80af9eb5b525a
--- /dev/null
+++ b/src/async-generators/yield-identifier-spread-non-strict.case
@@ -0,0 +1,49 @@
+// Copyright (C) 2017 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+desc: >
+  Mixed use of object spread and yield as a valid identifier in a function body
+  inside a generator body in non strict mode
+template: non-strict
+info: |
+  Spread Properties
+
+  PropertyDefinition[Yield]:
+    (...)
+    ...AssignmentExpression[In, ?Yield]
+features: [object-spread]
+flags: [noStrict, async]
+---*/
+
+//- setup
+var s = Symbol('s');
+//- body
+  yield {
+     ...yield yield,
+     ...(function(arg) {
+        var yield = arg;
+        return {...yield};
+     }(yield)),
+     ...yield,
+  }
+//- assertions
+var iter = gen();
+
+iter.next();
+iter.next();
+iter.next({ x: 10, a: 0, b: 0, [s]: 1 });
+iter.next({ y: 20, a: 1, b: 1, [s]: 42 });
+var item = iter.next({ z: 30, b: 2 });
+
+item.then(({ done, value }) => {
+  assert.sameValue(done, false);
+  assert.sameValue(value.x, 10);
+  assert.sameValue(value.y, 20);
+  assert.sameValue(value.z, 30);
+  assert.sameValue(value.a, 1);
+  assert.sameValue(value.b, 2);
+  assert.sameValue(value[s], 42);
+  assert.sameValue(Object.keys(value).length, 5);
+  assert(Object.hasOwnProperty.call(value, s));
+}).then($DONE, $DONE);
diff --git a/src/async-generators/yield-identifier-spread-strict.case b/src/async-generators/yield-identifier-spread-strict.case
new file mode 100644
index 0000000000000000000000000000000000000000..7c84ac4dae32a7ef6e8fe5e93de91a3bdfe139e7
--- /dev/null
+++ b/src/async-generators/yield-identifier-spread-strict.case
@@ -0,0 +1,28 @@
+// Copyright (C) 2017 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+desc: >
+  It's an early error if the AssignmentExpression is a function body with yield
+  as an identifier in strict mode.
+template: default
+info: |
+  Spread Properties
+
+  PropertyDefinition[Yield]:
+    (...)
+    ...AssignmentExpression[In, ?Yield]
+features: [object-spread]
+flags: [onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+---*/
+
+//- body
+  return {
+     ...(function() {
+        var yield;
+        throw new Test262Error();
+     }()),
+  }
diff --git a/src/async-generators/yield-identifier-strict.case b/src/async-generators/yield-identifier-strict.case
new file mode 100644
index 0000000000000000000000000000000000000000..6c9e49f8288c97dda0bb6884129787a389928acc
--- /dev/null
+++ b/src/async-generators/yield-identifier-strict.case
@@ -0,0 +1,19 @@
+// Copyright (C) 2017 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+desc: >
+  It's an early error if the generator body has another function body with
+  yield as an identifier in strict mode.
+template: default
+flags: [onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+---*/
+
+//- body
+  (function() {
+    var yield;
+    throw new Test262Error();
+  }())
diff --git a/src/async-generators/yield-spread-arr-multiple.case b/src/async-generators/yield-spread-arr-multiple.case
new file mode 100644
index 0000000000000000000000000000000000000000..33f431766b985bfbb062d3517c5a7d27e5729aae
--- /dev/null
+++ b/src/async-generators/yield-spread-arr-multiple.case
@@ -0,0 +1,33 @@
+// Copyright (C) 2017 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+desc: Use yield value in a array spread position
+template: default
+info: |
+  Array Initializer
+
+  SpreadElement[Yield, Await]:
+    ...AssignmentExpression[+In, ?Yield, ?Await]
+includes:
+  - compareArray.js
+flags: [async]
+---*/
+
+//- setup
+var arr = ['a', 'b', 'c'];
+var item;
+//- body
+  yield [...yield yield];
+//- assertions
+iter.next(false);
+item = iter.next(['a', 'b', 'c']);
+
+item.then(({ done, value }) => {
+  item = iter.next(value);
+
+  item.then(({ done, value }) => {
+    assert(compareArray(value, arr));
+    assert.sameValue(done, false);
+  }).then($DONE, $DONE);
+}).catch($DONE);
diff --git a/src/async-generators/yield-spread-arr-single.case b/src/async-generators/yield-spread-arr-single.case
new file mode 100644
index 0000000000000000000000000000000000000000..cc7cb640b64ea3360d00a39ea23daaac7147fd27
--- /dev/null
+++ b/src/async-generators/yield-spread-arr-single.case
@@ -0,0 +1,31 @@
+// Copyright (C) 2017 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+desc: Use yield value in a array spread position
+template: default
+info: |
+  Array Initializer
+
+  SpreadElement[Yield, Await]:
+    ...AssignmentExpression[+In, ?Yield, ?Await]
+flags: [async]
+---*/
+
+//- setup
+var arr = ['a', 'b', 'c'];
+//- body
+  yield [...yield];
+//- assertions
+iter.next(false);
+var item = iter.next(arr);
+
+item.then(({ done, value }) => {
+  assert.notSameValue(value, arr, 'value is a new array');
+  assert(Array.isArray(value), 'value is an Array exotic object');
+  assert.sameValue(value.length, 3)
+  assert.sameValue(value[0], 'a');
+  assert.sameValue(value[1], 'b');
+  assert.sameValue(value[2], 'c');
+  assert.sameValue(done, false);
+}).then($DONE, $DONE);
diff --git a/src/async-generators/yield-spread-obj.case b/src/async-generators/yield-spread-obj.case
new file mode 100644
index 0000000000000000000000000000000000000000..f7d14c022ab71c9259054f00a9c9e34aaff49851
--- /dev/null
+++ b/src/async-generators/yield-spread-obj.case
@@ -0,0 +1,36 @@
+// Copyright (C) 2017 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+
+/*---
+desc: Use yield value in a object spread position
+template: default
+info: |
+  Spread Properties
+
+  PropertyDefinition[Yield]:
+    (...)
+    ...AssignmentExpression[In, ?Yield]
+features: [object-spread]
+includes:
+  - compareArray.js
+flags: [async]
+---*/
+
+//- body
+  yield {
+    ...yield,
+    y: 1,
+    ...yield yield,
+  };
+//- assertions
+iter.next();
+iter.next({ x: 42 });
+iter.next({ x: 'lol' });
+var item = iter.next({ y: 39 });
+
+item.then(({ done, value }) => {
+  assert.sameValue(value.x, 42);
+  assert.sameValue(value.y, 39);
+  assert.sameValue(Object.keys(value).length, 2);
+  assert.sameValue(done, false);
+}).then($DONE, $DONE);
diff --git a/src/generators/default/class-decl-method.template b/src/generators/default/class-decl-method.template
new file mode 100644
index 0000000000000000000000000000000000000000..ad4959030724a7d7c8fe975beb8ba21650cbf126
--- /dev/null
+++ b/src/generators/default/class-decl-method.template
@@ -0,0 +1,33 @@
+// Copyright (C) 2017 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/statements/class/gen-method-
+name: Geenerator method as a ClassDeclaration element
+esid: prod-GeneratorMethod
+info: |
+  ClassElement :
+    MethodDefinition
+
+  MethodDefinition :
+    GeneratorMethod
+
+  14.4 Generator Function Definitions
+
+  GeneratorMethod :
+    * PropertyName ( UniqueFormalParameters ) { GeneratorBody }
+---*/
+
+var callCount = 0;
+
+class C { *gen() {
+    callCount += 1;
+    /*{ body }*/
+}}
+
+var gen = C.prototype.gen;
+
+var iter = gen();
+
+/*{ assertions }*/
+
+assert.sameValue(callCount, 1);
diff --git a/src/generators/default/class-decl-static-method.template b/src/generators/default/class-decl-static-method.template
new file mode 100644
index 0000000000000000000000000000000000000000..dcd8f4e68c8c60a0db1a2b9a7073edde58b51a0c
--- /dev/null
+++ b/src/generators/default/class-decl-static-method.template
@@ -0,0 +1,33 @@
+// Copyright (C) 2017 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/statements/class/gen-method-static-
+name: Static generator method as a ClassDeclaration element
+esid: prod-GeneratorMethod
+info: |
+  ClassElement :
+    static MethodDefinition
+
+  MethodDefinition :
+    GeneratorMethod
+
+  14.4 Generator Function Definitions
+
+  GeneratorMethod :
+    * PropertyName ( UniqueFormalParameters ) { GeneratorBody }
+---*/
+
+var callCount = 0;
+
+class C {static *gen() {
+    callCount += 1;
+    /*{ body }*/
+}}
+
+var gen = C.gen;
+
+var iter = gen();
+
+/*{ assertions }*/
+
+assert.sameValue(callCount, 1);
diff --git a/src/generators/default/class-method-definition.template b/src/generators/default/class-expr-method.template
similarity index 56%
rename from src/generators/default/class-method-definition.template
rename to src/generators/default/class-expr-method.template
index 4515d51ef532e258330489ef945eec2743a98ed9..8580bb939187bd8390f0c66ae8c86b49b47ee534 100644
--- a/src/generators/default/class-method-definition.template
+++ b/src/generators/default/class-expr-method.template
@@ -2,24 +2,24 @@
 // This code is governed by the BSD license found in the LICENSE file.
 /*---
 path: language/expressions/class/gen-method-
-name: Generator method as a ClassElement
+name: Generator method as a ClassExpression element
 esid: prod-GeneratorMethod
 info: |
-  ClassElement[Yield, Await]:
-    MethodDefinition[?Yield, ?Await]
+  ClassElement :
+    MethodDefinition
 
-  MethodDefinition[Yield, Await]:
-    GeneratorMethod[?Yield, ?Await]
+  MethodDefinition :
+    GeneratorMethod
 
   14.4 Generator Function Definitions
 
-  GeneratorMethod[Yield, Await]:
-    * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { GeneratorBody }
+  GeneratorMethod :
+    * PropertyName ( UniqueFormalParameters ) { GeneratorBody }
 ---*/
 
 var callCount = 0;
 
-class C { *gen() {
+var C = class {*gen() {
     callCount += 1;
     /*{ body }*/
 }}
diff --git a/src/generators/default/class-expr-static-method.template b/src/generators/default/class-expr-static-method.template
new file mode 100644
index 0000000000000000000000000000000000000000..dd6e4ef0f72dc1667c4902759deb49b62748c11a
--- /dev/null
+++ b/src/generators/default/class-expr-static-method.template
@@ -0,0 +1,33 @@
+// Copyright (C) 2017 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/class/gen-method-static-
+name: Static generator method as a ClassExpression element
+esid: prod-GeneratorMethod
+info: |
+  ClassElement :
+    static MethodDefinition
+
+  MethodDefinition :
+    GeneratorMethod
+
+  14.4 Generator Function Definitions
+
+  GeneratorMethod :
+    * PropertyName ( UniqueFormalParameters ) { GeneratorBody }
+---*/
+
+var callCount = 0;
+
+var C = class { static *gen() {
+    callCount += 1;
+    /*{ body }*/
+}}
+
+var gen = C.gen;
+
+var iter = gen();
+
+/*{ assertions }*/
+
+assert.sameValue(callCount, 1);
diff --git a/src/generators/default/statement.template b/src/generators/default/declaration.template
similarity index 68%
rename from src/generators/default/statement.template
rename to src/generators/default/declaration.template
index d70481d62f4c369d558e3fa0a08d04c3562cc363..c9454f69210e800deb95a86e57e2720e50e5709e 100644
--- a/src/generators/default/statement.template
+++ b/src/generators/default/declaration.template
@@ -2,13 +2,13 @@
 // This code is governed by the BSD license found in the LICENSE file.
 /*---
 path: language/statements/generators/
-name: Generator function declaration
+name: Generator Function declaration
 esid: prod-GeneratorDeclaration
 info: |
   14.4 Generator Function Definitions
 
-  GeneratorDeclaration[Yield, Await, Default]:
-    function * BindingIdentifier[?Yield, ?Await] ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+  GeneratorDeclaration :
+    function * BindingIdentifier ( FormalParameters ) { GeneratorBody }
 ---*/
 
 var callCount = 0;
diff --git a/src/generators/default/expression-named.template b/src/generators/default/expression-named.template
new file mode 100644
index 0000000000000000000000000000000000000000..1a2ad892d909733e3f3a679091fb748b8adf8ed6
--- /dev/null
+++ b/src/generators/default/expression-named.template
@@ -0,0 +1,25 @@
+// Copyright (C) 2017 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/generators/named-
+name: Named generator expression
+esid: prod-GeneratorExpression
+info: |
+  14.4 Generator Function Definitions
+
+  GeneratorExpression:
+    function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody }
+---*/
+
+var callCount = 0;
+
+var gen = function *g() {
+  callCount += 1;
+  /*{ body }*/
+};
+
+var iter = gen();
+
+/*{ assertions }*/
+
+assert.sameValue(callCount, 1);
diff --git a/src/generators/default/expression.template b/src/generators/default/expression.template
index ddead781f517d013651f518821dec6641003e14e..f66994b8b16ec8b04076525c7e019718f98a3e7f 100644
--- a/src/generators/default/expression.template
+++ b/src/generators/default/expression.template
@@ -2,13 +2,13 @@
 // This code is governed by the BSD license found in the LICENSE file.
 /*---
 path: language/expressions/generators/
-name: Generator expression
+name: Unnamed generator expression
 esid: prod-GeneratorExpression
 info: |
   14.4 Generator Function Definitions
 
   GeneratorExpression:
-    function * BindingIdentifier[+Yield, ~Await]opt ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+    function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody }
 ---*/
 
 var callCount = 0;
diff --git a/src/generators/default/method-definition.template b/src/generators/default/obj-method.template
similarity index 89%
rename from src/generators/default/method-definition.template
rename to src/generators/default/obj-method.template
index d075f36830b4e1f0bab40ef2db1b081da0aea120..d909462bc74d0ff42d8a29af29e83cc9f83c738b 100644
--- a/src/generators/default/method-definition.template
+++ b/src/generators/default/obj-method.template
@@ -1,7 +1,7 @@
 // Copyright (C) 2017 the V8 project authors. All rights reserved.
 // This code is governed by the BSD license found in the LICENSE file.
 /*---
-path: language/expressions/object/method-definition/generator-
+path: language/expressions/object/method-definition/gen-
 name: Generator method
 esid: prod-GeneratorMethod
 info: |
diff --git a/src/generators/non-strict/statement.template b/src/generators/non-strict/declaration.template
similarity index 100%
rename from src/generators/non-strict/statement.template
rename to src/generators/non-strict/declaration.template
diff --git a/src/generators/non-strict/expression-named.template b/src/generators/non-strict/expression-named.template
new file mode 100644
index 0000000000000000000000000000000000000000..43448e09632847da7052c6e84eb559c12ea32881
--- /dev/null
+++ b/src/generators/non-strict/expression-named.template
@@ -0,0 +1,25 @@
+// Copyright (C) 2017 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+path: language/expressions/generators/named-
+name: Generator named expression - valid for non-strict only cases
+esid: prod-GeneratorExpression
+info: |
+  14.4 Generator Function Definitions
+
+  GeneratorExpression:
+    function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody }
+---*/
+
+var callCount = 0;
+
+var gen = function *g() {
+  callCount += 1;
+  /*{ body }*/
+};
+
+var iter = gen();
+
+/*{ assertions }*/
+
+assert.sameValue(callCount, 1);
diff --git a/src/generators/non-strict/expression.template b/src/generators/non-strict/expression.template
index 1237f25f660722248b0ad12fde8cf89efa791144..285a84b75be02504454d83d3e89d74f17ff62e99 100644
--- a/src/generators/non-strict/expression.template
+++ b/src/generators/non-strict/expression.template
@@ -8,7 +8,7 @@ info: |
   14.4 Generator Function Definitions
 
   GeneratorExpression:
-    function * BindingIdentifier[+Yield, ~Await]opt ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+    function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody }
 ---*/
 
 var callCount = 0;
diff --git a/src/generators/non-strict/method-definition.template b/src/generators/non-strict/obj-method.template
similarity index 75%
rename from src/generators/non-strict/method-definition.template
rename to src/generators/non-strict/obj-method.template
index 84cee1cfd1d7d968f78c0e2cc8c9274134b6acb6..67b6e23377e91f363748b71bd32e2632d95e2900 100644
--- a/src/generators/non-strict/method-definition.template
+++ b/src/generators/non-strict/obj-method.template
@@ -1,14 +1,14 @@
 // Copyright (C) 2017 the V8 project authors. All rights reserved.
 // This code is governed by the BSD license found in the LICENSE file.
 /*---
-path: language/expressions/object/method-definition/generator-
+path: language/expressions/object/method-definition/gen-
 name: Generator method - valid for non-strict only cases
 esid: prod-GeneratorMethod
 info: |
   14.4 Generator Function Definitions
 
   GeneratorMethod[Yield, Await]:
-    * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { GeneratorBody }
+    * PropertyName ( UniqueFormalParameters ) { GeneratorBody }
 ---*/
 
 var callCount = 0;
diff --git a/src/generators/yield-identifier-spread-non-strict.case b/src/generators/yield-identifier-spread-non-strict.case
index 219b749fa45b4c3e45e3c5f7fe481ca07a756d41..f4ad4f40b5c8f881e7be2ec2365a2782d9b0b4db 100644
--- a/src/generators/yield-identifier-spread-non-strict.case
+++ b/src/generators/yield-identifier-spread-non-strict.case
@@ -16,6 +16,8 @@ features: [object-spread]
 flags: [noStrict]
 ---*/
 
+//- setup
+var s = Symbol('s');
 //- body
   yield {
      ...yield yield,
@@ -30,14 +32,18 @@ var iter = gen();
 
 iter.next();
 iter.next();
-iter.next({ x: 10, a: 0, b: 0 });
-iter.next({ y: 20, a: 1, b: 1 });
+iter.next({ x: 10, a: 0, b: 0, [s]: 1 });
+iter.next({ y: 20, a: 1, b: 1, [s]: 42 });
 var item = iter.next({ z: 30, b: 2 });
 
+var value = item.value;
+
 assert.sameValue(item.done, false);
-assert.sameValue(item.value.x, 10);
-assert.sameValue(item.value.y, 20);
-assert.sameValue(item.value.z, 30);
-assert.sameValue(item.value.a, 1);
-assert.sameValue(item.value.b, 2);
-assert.sameValue(Object.keys(item.value).length, 5);
+assert.sameValue(value.x, 10);
+assert.sameValue(value.y, 20);
+assert.sameValue(value.z, 30);
+assert.sameValue(value.a, 1);
+assert.sameValue(value.b, 2);
+assert.sameValue(value[s], 42);
+assert(Object.hasOwnProperty.call(value, s));
+assert.sameValue(Object.keys(value).length, 5);
diff --git a/src/generators/yield-spread-arr-single.case b/src/generators/yield-spread-arr-single.case
index 5f31c2ddf6e285784922de9da9b6829edd7c9083..e3f6b8d5f1521760a5ef2e11961c4ff6ffc084c9 100644
--- a/src/generators/yield-spread-arr-single.case
+++ b/src/generators/yield-spread-arr-single.case
@@ -9,8 +9,6 @@ info: |
 
   SpreadElement[Yield, Await]:
     ...AssignmentExpression[+In, ?Yield, ?Await]
-includes:
-  - compareArray.js
 ---*/
 
 //- setup
@@ -19,7 +17,13 @@ var arr = ['a', 'b', 'c'];
   yield [...yield];
 //- assertions
 iter.next(false);
-var item = iter.next(['a', 'b', 'c']);
+var item = iter.next(arr);
+var value = item.value;
 
-assert(compareArray(item.value, arr));
+assert.notSameValue(value, arr, 'value is a new array');
+assert(Array.isArray(value), 'value is an Array exotic object');
+assert.sameValue(value.length, 3)
+assert.sameValue(value[0], 'a');
+assert.sameValue(value[1], 'b');
+assert.sameValue(value[2], 'c');
 assert.sameValue(item.done, false);
diff --git a/src/spread/obj-symbol-property.case b/src/spread/obj-symbol-property.case
index 87a98695648651910c89ee31a25bd65c1935f7c4..3d3e922aacfbe166857daa2ae2fc5624288b0fac 100644
--- a/src/spread/obj-symbol-property.case
+++ b/src/spread/obj-symbol-property.case
@@ -29,6 +29,7 @@ obj
 //- body
 
 assert.sameValue(obj[symbol], 1);
+assert(Object.hasOwnProperty.call(obj, symbol));
 assert.sameValue(obj.c, 4);
 assert.sameValue(obj.d, 5);
 assert.sameValue(Object.keys(obj).length, 2);
diff --git a/test/language/expressions/array/spread-obj-symbol-property.js b/test/language/expressions/array/spread-obj-symbol-property.js
index 8a8cedcebe7eb3488a35d5a86c341002bc9e83e9..7965be97151108599ea7a226e924cc4b21b9b92d 100644
--- a/test/language/expressions/array/spread-obj-symbol-property.js
+++ b/test/language/expressions/array/spread-obj-symbol-property.js
@@ -41,6 +41,7 @@ var callCount = 0;
 
 (function(obj) {
   assert.sameValue(obj[symbol], 1);
+  assert(Object.hasOwnProperty.call(obj, symbol));
   assert.sameValue(obj.c, 4);
   assert.sameValue(obj.d, 5);
   assert.sameValue(Object.keys(obj).length, 2);
diff --git a/test/language/expressions/async-generators/early-errors-expression-NSPL-with-USD.js b/test/language/expressions/async-generator/early-errors-expression-NSPL-with-USD.js
similarity index 100%
rename from test/language/expressions/async-generators/early-errors-expression-NSPL-with-USD.js
rename to test/language/expressions/async-generator/early-errors-expression-NSPL-with-USD.js
diff --git a/test/language/expressions/async-generators/early-errors-expression-arguments-in-formal-parameters.js b/test/language/expressions/async-generator/early-errors-expression-arguments-in-formal-parameters.js
similarity index 100%
rename from test/language/expressions/async-generators/early-errors-expression-arguments-in-formal-parameters.js
rename to test/language/expressions/async-generator/early-errors-expression-arguments-in-formal-parameters.js
diff --git a/test/language/expressions/async-generators/early-errors-expression-await-as-function-binding-identifier.js b/test/language/expressions/async-generator/early-errors-expression-await-as-function-binding-identifier.js
similarity index 100%
rename from test/language/expressions/async-generators/early-errors-expression-await-as-function-binding-identifier.js
rename to test/language/expressions/async-generator/early-errors-expression-await-as-function-binding-identifier.js
diff --git a/test/language/expressions/async-generators/early-errors-expression-binding-identifier-arguments.js b/test/language/expressions/async-generator/early-errors-expression-binding-identifier-arguments.js
similarity index 100%
rename from test/language/expressions/async-generators/early-errors-expression-binding-identifier-arguments.js
rename to test/language/expressions/async-generator/early-errors-expression-binding-identifier-arguments.js
diff --git a/test/language/expressions/async-generators/early-errors-expression-binding-identifier-eval.js b/test/language/expressions/async-generator/early-errors-expression-binding-identifier-eval.js
similarity index 100%
rename from test/language/expressions/async-generators/early-errors-expression-binding-identifier-eval.js
rename to test/language/expressions/async-generator/early-errors-expression-binding-identifier-eval.js
diff --git a/test/language/expressions/async-generators/early-errors-expression-body-contains-super-call.js b/test/language/expressions/async-generator/early-errors-expression-body-contains-super-call.js
similarity index 100%
rename from test/language/expressions/async-generators/early-errors-expression-body-contains-super-call.js
rename to test/language/expressions/async-generator/early-errors-expression-body-contains-super-call.js
diff --git a/test/language/expressions/async-generators/early-errors-expression-body-contains-super-property.js b/test/language/expressions/async-generator/early-errors-expression-body-contains-super-property.js
similarity index 100%
rename from test/language/expressions/async-generators/early-errors-expression-body-contains-super-property.js
rename to test/language/expressions/async-generator/early-errors-expression-body-contains-super-property.js
diff --git a/test/language/expressions/async-generators/early-errors-expression-eval-in-formal-parameters.js b/test/language/expressions/async-generator/early-errors-expression-eval-in-formal-parameters.js
similarity index 100%
rename from test/language/expressions/async-generators/early-errors-expression-eval-in-formal-parameters.js
rename to test/language/expressions/async-generator/early-errors-expression-eval-in-formal-parameters.js
diff --git a/test/language/expressions/async-generators/early-errors-expression-formals-body-duplicate-const.js b/test/language/expressions/async-generator/early-errors-expression-formals-body-duplicate-const.js
similarity index 100%
rename from test/language/expressions/async-generators/early-errors-expression-formals-body-duplicate-const.js
rename to test/language/expressions/async-generator/early-errors-expression-formals-body-duplicate-const.js
diff --git a/test/language/expressions/async-generators/early-errors-expression-formals-body-duplicate-let.js b/test/language/expressions/async-generator/early-errors-expression-formals-body-duplicate-let.js
similarity index 100%
rename from test/language/expressions/async-generators/early-errors-expression-formals-body-duplicate-let.js
rename to test/language/expressions/async-generator/early-errors-expression-formals-body-duplicate-let.js
diff --git a/test/language/expressions/async-generators/early-errors-expression-formals-contains-await-expr.js b/test/language/expressions/async-generator/early-errors-expression-formals-contains-await-expr.js
similarity index 100%
rename from test/language/expressions/async-generators/early-errors-expression-formals-contains-await-expr.js
rename to test/language/expressions/async-generator/early-errors-expression-formals-contains-await-expr.js
diff --git a/test/language/expressions/async-generators/early-errors-expression-formals-contains-await.js b/test/language/expressions/async-generator/early-errors-expression-formals-contains-await.js
similarity index 100%
rename from test/language/expressions/async-generators/early-errors-expression-formals-contains-await.js
rename to test/language/expressions/async-generator/early-errors-expression-formals-contains-await.js
diff --git a/test/language/expressions/async-generators/early-errors-expression-formals-contains-super-call.js b/test/language/expressions/async-generator/early-errors-expression-formals-contains-super-call.js
similarity index 100%
rename from test/language/expressions/async-generators/early-errors-expression-formals-contains-super-call.js
rename to test/language/expressions/async-generator/early-errors-expression-formals-contains-super-call.js
diff --git a/test/language/expressions/async-generators/early-errors-expression-formals-contains-super-property.js b/test/language/expressions/async-generator/early-errors-expression-formals-contains-super-property.js
similarity index 100%
rename from test/language/expressions/async-generators/early-errors-expression-formals-contains-super-property.js
rename to test/language/expressions/async-generator/early-errors-expression-formals-contains-super-property.js
diff --git a/test/language/expressions/async-generators/early-errors-expression-formals-contains-yield-expr.js b/test/language/expressions/async-generator/early-errors-expression-formals-contains-yield-expr.js
similarity index 100%
rename from test/language/expressions/async-generators/early-errors-expression-formals-contains-yield-expr.js
rename to test/language/expressions/async-generator/early-errors-expression-formals-contains-yield-expr.js
diff --git a/test/language/expressions/async-generators/early-errors-expression-formals-contains-yield.js b/test/language/expressions/async-generator/early-errors-expression-formals-contains-yield.js
similarity index 100%
rename from test/language/expressions/async-generators/early-errors-expression-formals-contains-yield.js
rename to test/language/expressions/async-generator/early-errors-expression-formals-contains-yield.js
diff --git a/test/language/expressions/async-generators/early-errors-expression-label-name-await.js b/test/language/expressions/async-generator/early-errors-expression-label-name-await.js
similarity index 100%
rename from test/language/expressions/async-generators/early-errors-expression-label-name-await.js
rename to test/language/expressions/async-generator/early-errors-expression-label-name-await.js
diff --git a/test/language/expressions/async-generators/early-errors-expression-label-name-yield.js b/test/language/expressions/async-generator/early-errors-expression-label-name-yield.js
similarity index 100%
rename from test/language/expressions/async-generators/early-errors-expression-label-name-yield.js
rename to test/language/expressions/async-generator/early-errors-expression-label-name-yield.js
diff --git a/test/language/expressions/async-generators/early-errors-expression-not-simple-assignment-target.js b/test/language/expressions/async-generator/early-errors-expression-not-simple-assignment-target.js
similarity index 100%
rename from test/language/expressions/async-generators/early-errors-expression-not-simple-assignment-target.js
rename to test/language/expressions/async-generator/early-errors-expression-not-simple-assignment-target.js
diff --git a/test/language/expressions/async-generators/early-errors-expression-yield-as-function-binding-identifier.js b/test/language/expressions/async-generator/early-errors-expression-yield-as-function-binding-identifier.js
similarity index 100%
rename from test/language/expressions/async-generators/early-errors-expression-yield-as-function-binding-identifier.js
rename to test/language/expressions/async-generator/early-errors-expression-yield-as-function-binding-identifier.js
diff --git a/test/language/expressions/async-generators/early-errors-expression-yield-star-after-newline.js b/test/language/expressions/async-generator/early-errors-expression-yield-star-after-newline.js
similarity index 100%
rename from test/language/expressions/async-generators/early-errors-expression-yield-star-after-newline.js
rename to test/language/expressions/async-generator/early-errors-expression-yield-star-after-newline.js
diff --git a/test/language/expressions/async-generators/expression-await-as-yield-operand.js b/test/language/expressions/async-generator/expression-await-as-yield-operand.js
similarity index 100%
rename from test/language/expressions/async-generators/expression-await-as-yield-operand.js
rename to test/language/expressions/async-generator/expression-await-as-yield-operand.js
diff --git a/test/language/expressions/async-generators/expression-await-promise-as-yield-operand.js b/test/language/expressions/async-generator/expression-await-promise-as-yield-operand.js
similarity index 100%
rename from test/language/expressions/async-generators/expression-await-promise-as-yield-operand.js
rename to test/language/expressions/async-generator/expression-await-promise-as-yield-operand.js
diff --git a/test/language/expressions/async-generators/expression-await-thenable-as-yield-operand.js b/test/language/expressions/async-generator/expression-await-thenable-as-yield-operand.js
similarity index 100%
rename from test/language/expressions/async-generators/expression-await-thenable-as-yield-operand.js
rename to test/language/expressions/async-generator/expression-await-thenable-as-yield-operand.js
diff --git a/test/language/expressions/async-generators/expression-yield-as-operand.js b/test/language/expressions/async-generator/expression-yield-as-operand.js
similarity index 100%
rename from test/language/expressions/async-generators/expression-yield-as-operand.js
rename to test/language/expressions/async-generator/expression-yield-as-operand.js
diff --git a/test/language/expressions/async-generators/expression-yield-as-statement.js b/test/language/expressions/async-generator/expression-yield-as-statement.js
similarity index 100%
rename from test/language/expressions/async-generators/expression-yield-as-statement.js
rename to test/language/expressions/async-generator/expression-yield-as-statement.js
diff --git a/test/language/expressions/async-generators/expression-yield-newline.js b/test/language/expressions/async-generator/expression-yield-newline.js
similarity index 100%
rename from test/language/expressions/async-generators/expression-yield-newline.js
rename to test/language/expressions/async-generator/expression-yield-newline.js
diff --git a/test/language/expressions/async-generators/expression-yield-star-before-newline.js b/test/language/expressions/async-generator/expression-yield-star-before-newline.js
similarity index 100%
rename from test/language/expressions/async-generators/expression-yield-star-before-newline.js
rename to test/language/expressions/async-generator/expression-yield-star-before-newline.js
diff --git a/test/language/expressions/async-generator/named-yield-identifier-non-strict.js b/test/language/expressions/async-generator/named-yield-identifier-non-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..f40bbe0e54928d887e54b7b8770b389e91250d74
--- /dev/null
+++ b/test/language/expressions/async-generator/named-yield-identifier-non-strict.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-identifier-non-strict.case
+// - src/async-generators/non-strict/async-expression-named.template
+/*---
+description: Use of yield as a valid identifier in a function body inside a generator body in non strict mode (Async generator named expression - valid for non-strict only cases)
+esid: prod-AsyncGeneratorExpression
+features: [async-iteration]
+flags: [generated, noStrict, async]
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorExpression :
+      async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
+        AsyncGeneratorBody }
+
+---*/
+
+
+var callCount = 0;
+
+var gen = async function *g() {
+  callCount += 1;
+  return (function(arg) {
+      var yield = arg + 1;
+      return yield;
+    }(yield))
+};
+
+var iter = gen();
+
+var item = iter.next();
+
+item.then(({ done, value }) => {
+  assert.sameValue(done, false);
+  assert.sameValue(value, undefined);
+});
+
+item = iter.next(42);
+
+item.then(({ done, value }) => {
+  assert.sameValue(done, true);
+  assert.sameValue(value, 43);
+}).then($DONE, $DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/async-generator/named-yield-identifier-spread-non-strict.js b/test/language/expressions/async-generator/named-yield-identifier-spread-non-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..6c7ae2960f26a661f624d0aefb4084d2e0821e80
--- /dev/null
+++ b/test/language/expressions/async-generator/named-yield-identifier-spread-non-strict.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-identifier-spread-non-strict.case
+// - src/async-generators/non-strict/async-expression-named.template
+/*---
+description: Mixed use of object spread and yield as a valid identifier in a function body inside a generator body in non strict mode (Async generator named expression - valid for non-strict only cases)
+esid: prod-AsyncGeneratorExpression
+features: [object-spread, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorExpression :
+      async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
+        AsyncGeneratorBody }
+
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+var s = Symbol('s');
+
+
+var callCount = 0;
+
+var gen = async function *g() {
+  callCount += 1;
+  yield {
+       ...yield yield,
+       ...(function(arg) {
+          var yield = arg;
+          return {...yield};
+       }(yield)),
+       ...yield,
+    }
+};
+
+var iter = gen();
+
+var iter = gen();
+
+iter.next();
+iter.next();
+iter.next({ x: 10, a: 0, b: 0, [s]: 1 });
+iter.next({ y: 20, a: 1, b: 1, [s]: 42 });
+var item = iter.next({ z: 30, b: 2 });
+
+item.then(({ done, value }) => {
+  assert.sameValue(done, false);
+  assert.sameValue(value.x, 10);
+  assert.sameValue(value.y, 20);
+  assert.sameValue(value.z, 30);
+  assert.sameValue(value.a, 1);
+  assert.sameValue(value.b, 2);
+  assert.sameValue(value[s], 42);
+  assert.sameValue(Object.keys(value).length, 5);
+  assert(Object.hasOwnProperty.call(value, s));
+}).then($DONE, $DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/async-generator/named-yield-identifier-spread-strict.js b/test/language/expressions/async-generator/named-yield-identifier-spread-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..a368ba6c3ed79386fc52e39b42573baae9ac731c
--- /dev/null
+++ b/test/language/expressions/async-generator/named-yield-identifier-spread-strict.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-identifier-spread-strict.case
+// - src/async-generators/default/async-expression-named.template
+/*---
+description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Named async generator expression)
+esid: prod-AsyncGeneratorExpression
+features: [object-spread, async-iteration]
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorExpression :
+      async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
+        AsyncGeneratorBody }
+
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+
+var callCount = 0;
+
+var gen = async function *g() {
+  callCount += 1;
+  return {
+       ...(function() {
+          var yield;
+          throw new Test262Error();
+       }()),
+    }
+};
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/async-generator/named-yield-identifier-strict.js b/test/language/expressions/async-generator/named-yield-identifier-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..6c2b9d59e890bbd788c589b6599aca35fa7bb0aa
--- /dev/null
+++ b/test/language/expressions/async-generator/named-yield-identifier-strict.js
@@ -0,0 +1,36 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-identifier-strict.case
+// - src/async-generators/default/async-expression-named.template
+/*---
+description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Named async generator expression)
+esid: prod-AsyncGeneratorExpression
+features: [async-iteration]
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorExpression :
+      async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
+        AsyncGeneratorBody }
+
+---*/
+
+
+var callCount = 0;
+
+var gen = async function *g() {
+  callCount += 1;
+  (function() {
+      var yield;
+      throw new Test262Error();
+    }())
+};
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/async-generator/named-yield-spread-arr-multiple.js b/test/language/expressions/async-generator/named-yield-spread-arr-multiple.js
new file mode 100644
index 0000000000000000000000000000000000000000..56c3a3cdf7028d034ef1ed1b0ee198f3e30c3e09
--- /dev/null
+++ b/test/language/expressions/async-generator/named-yield-spread-arr-multiple.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-spread-arr-multiple.case
+// - src/async-generators/default/async-expression-named.template
+/*---
+description: Use yield value in a array spread position (Named async generator expression)
+esid: prod-AsyncGeneratorExpression
+features: [async-iteration]
+flags: [generated, async]
+includes: [compareArray.js]
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorExpression :
+      async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
+        AsyncGeneratorBody }
+
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+
+---*/
+var arr = ['a', 'b', 'c'];
+var item;
+
+
+var callCount = 0;
+
+var gen = async function *g() {
+  callCount += 1;
+  yield [...yield yield];
+};
+
+var iter = gen();
+
+iter.next(false);
+item = iter.next(['a', 'b', 'c']);
+
+item.then(({ done, value }) => {
+  item = iter.next(value);
+
+  item.then(({ done, value }) => {
+    assert(compareArray(value, arr));
+    assert.sameValue(done, false);
+  }).then($DONE, $DONE);
+}).catch($DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/async-generator/named-yield-spread-arr-single.js b/test/language/expressions/async-generator/named-yield-spread-arr-single.js
new file mode 100644
index 0000000000000000000000000000000000000000..a7c1e8634aea0c934750fda9e0ee2a4f50776377
--- /dev/null
+++ b/test/language/expressions/async-generator/named-yield-spread-arr-single.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-spread-arr-single.case
+// - src/async-generators/default/async-expression-named.template
+/*---
+description: Use yield value in a array spread position (Named async generator expression)
+esid: prod-AsyncGeneratorExpression
+features: [async-iteration]
+flags: [generated, async]
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorExpression :
+      async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
+        AsyncGeneratorBody }
+
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+
+---*/
+var arr = ['a', 'b', 'c'];
+
+
+var callCount = 0;
+
+var gen = async function *g() {
+  callCount += 1;
+  yield [...yield];
+};
+
+var iter = gen();
+
+iter.next(false);
+var item = iter.next(arr);
+
+item.then(({ done, value }) => {
+  assert.notSameValue(value, arr, 'value is a new array');
+  assert(Array.isArray(value), 'value is an Array exotic object');
+  assert.sameValue(value.length, 3)
+  assert.sameValue(value[0], 'a');
+  assert.sameValue(value[1], 'b');
+  assert.sameValue(value[2], 'c');
+  assert.sameValue(done, false);
+}).then($DONE, $DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/async-generator/named-yield-spread-obj.js b/test/language/expressions/async-generator/named-yield-spread-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..a673d06bbaacd8d6c7f31d8a935dd6c51da70588
--- /dev/null
+++ b/test/language/expressions/async-generator/named-yield-spread-obj.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-spread-obj.case
+// - src/async-generators/default/async-expression-named.template
+/*---
+description: Use yield value in a object spread position (Named async generator expression)
+esid: prod-AsyncGeneratorExpression
+features: [object-spread, async-iteration]
+flags: [generated, async]
+includes: [compareArray.js]
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorExpression :
+      async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
+        AsyncGeneratorBody }
+
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+
+var callCount = 0;
+
+var gen = async function *g() {
+  callCount += 1;
+  yield {
+      ...yield,
+      y: 1,
+      ...yield yield,
+    };
+};
+
+var iter = gen();
+
+iter.next();
+iter.next({ x: 42 });
+iter.next({ x: 'lol' });
+var item = iter.next({ y: 39 });
+
+item.then(({ done, value }) => {
+  assert.sameValue(value.x, 42);
+  assert.sameValue(value.y, 39);
+  assert.sameValue(Object.keys(value).length, 2);
+  assert.sameValue(done, false);
+}).then($DONE, $DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/async-generators/return-suspendedStart-promise.js b/test/language/expressions/async-generator/return-suspendedStart-promise.js
similarity index 100%
rename from test/language/expressions/async-generators/return-suspendedStart-promise.js
rename to test/language/expressions/async-generator/return-suspendedStart-promise.js
diff --git a/test/language/expressions/async-generators/return-suspendedStart.js b/test/language/expressions/async-generator/return-suspendedStart.js
similarity index 100%
rename from test/language/expressions/async-generators/return-suspendedStart.js
rename to test/language/expressions/async-generator/return-suspendedStart.js
diff --git a/test/language/expressions/async-generators/return-suspendedYield-promise.js b/test/language/expressions/async-generator/return-suspendedYield-promise.js
similarity index 100%
rename from test/language/expressions/async-generators/return-suspendedYield-promise.js
rename to test/language/expressions/async-generator/return-suspendedYield-promise.js
diff --git a/test/language/expressions/async-generators/return-suspendedYield-try-finally-return.js b/test/language/expressions/async-generator/return-suspendedYield-try-finally-return.js
similarity index 100%
rename from test/language/expressions/async-generators/return-suspendedYield-try-finally-return.js
rename to test/language/expressions/async-generator/return-suspendedYield-try-finally-return.js
diff --git a/test/language/expressions/async-generators/return-suspendedYield-try-finally-throw.js b/test/language/expressions/async-generator/return-suspendedYield-try-finally-throw.js
similarity index 100%
rename from test/language/expressions/async-generators/return-suspendedYield-try-finally-throw.js
rename to test/language/expressions/async-generator/return-suspendedYield-try-finally-throw.js
diff --git a/test/language/expressions/async-generators/return-suspendedYield-try-finally.js b/test/language/expressions/async-generator/return-suspendedYield-try-finally.js
similarity index 100%
rename from test/language/expressions/async-generators/return-suspendedYield-try-finally.js
rename to test/language/expressions/async-generator/return-suspendedYield-try-finally.js
diff --git a/test/language/expressions/async-generators/return-suspendedYield.js b/test/language/expressions/async-generator/return-suspendedYield.js
similarity index 100%
rename from test/language/expressions/async-generators/return-suspendedYield.js
rename to test/language/expressions/async-generator/return-suspendedYield.js
diff --git a/test/language/expressions/async-generators/throw-suspendedStart-promise.js b/test/language/expressions/async-generator/throw-suspendedStart-promise.js
similarity index 100%
rename from test/language/expressions/async-generators/throw-suspendedStart-promise.js
rename to test/language/expressions/async-generator/throw-suspendedStart-promise.js
diff --git a/test/language/expressions/async-generators/throw-suspendedStart.js b/test/language/expressions/async-generator/throw-suspendedStart.js
similarity index 100%
rename from test/language/expressions/async-generators/throw-suspendedStart.js
rename to test/language/expressions/async-generator/throw-suspendedStart.js
diff --git a/test/language/expressions/async-generators/throw-suspendedYield-promise.js b/test/language/expressions/async-generator/throw-suspendedYield-promise.js
similarity index 100%
rename from test/language/expressions/async-generators/throw-suspendedYield-promise.js
rename to test/language/expressions/async-generator/throw-suspendedYield-promise.js
diff --git a/test/language/expressions/async-generators/throw-suspendedYield-try-catch.js b/test/language/expressions/async-generator/throw-suspendedYield-try-catch.js
similarity index 100%
rename from test/language/expressions/async-generators/throw-suspendedYield-try-catch.js
rename to test/language/expressions/async-generator/throw-suspendedYield-try-catch.js
diff --git a/test/language/expressions/async-generators/throw-suspendedYield-try-finally-return.js b/test/language/expressions/async-generator/throw-suspendedYield-try-finally-return.js
similarity index 100%
rename from test/language/expressions/async-generators/throw-suspendedYield-try-finally-return.js
rename to test/language/expressions/async-generator/throw-suspendedYield-try-finally-return.js
diff --git a/test/language/expressions/async-generators/throw-suspendedYield-try-finally-throw.js b/test/language/expressions/async-generator/throw-suspendedYield-try-finally-throw.js
similarity index 100%
rename from test/language/expressions/async-generators/throw-suspendedYield-try-finally-throw.js
rename to test/language/expressions/async-generator/throw-suspendedYield-try-finally-throw.js
diff --git a/test/language/expressions/async-generators/throw-suspendedYield-try-finally.js b/test/language/expressions/async-generator/throw-suspendedYield-try-finally.js
similarity index 100%
rename from test/language/expressions/async-generators/throw-suspendedYield-try-finally.js
rename to test/language/expressions/async-generator/throw-suspendedYield-try-finally.js
diff --git a/test/language/expressions/async-generators/throw-suspendedYield.js b/test/language/expressions/async-generator/throw-suspendedYield.js
similarity index 100%
rename from test/language/expressions/async-generators/throw-suspendedYield.js
rename to test/language/expressions/async-generator/throw-suspendedYield.js
diff --git a/test/language/expressions/async-generator/yield-identifier-non-strict.js b/test/language/expressions/async-generator/yield-identifier-non-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..347e5fcd0a2c6651b4145f048b9c6dd010ec1506
--- /dev/null
+++ b/test/language/expressions/async-generator/yield-identifier-non-strict.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-identifier-non-strict.case
+// - src/async-generators/non-strict/async-expression.template
+/*---
+description: Use of yield as a valid identifier in a function body inside a generator body in non strict mode (Async generator expression - valid for non-strict only cases)
+esid: prod-AsyncGeneratorExpression
+features: [async-iteration]
+flags: [generated, noStrict, async]
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorExpression :
+      async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
+        AsyncGeneratorBody }
+
+---*/
+
+
+var callCount = 0;
+
+var gen = async function *() {
+  callCount += 1;
+  return (function(arg) {
+      var yield = arg + 1;
+      return yield;
+    }(yield))
+};
+
+var iter = gen();
+
+var item = iter.next();
+
+item.then(({ done, value }) => {
+  assert.sameValue(done, false);
+  assert.sameValue(value, undefined);
+});
+
+item = iter.next(42);
+
+item.then(({ done, value }) => {
+  assert.sameValue(done, true);
+  assert.sameValue(value, 43);
+}).then($DONE, $DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/async-generator/yield-identifier-spread-non-strict.js b/test/language/expressions/async-generator/yield-identifier-spread-non-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..90bcbe2ed0949b98b03fb489ca72922a2b1fb6d2
--- /dev/null
+++ b/test/language/expressions/async-generator/yield-identifier-spread-non-strict.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-identifier-spread-non-strict.case
+// - src/async-generators/non-strict/async-expression.template
+/*---
+description: Mixed use of object spread and yield as a valid identifier in a function body inside a generator body in non strict mode (Async generator expression - valid for non-strict only cases)
+esid: prod-AsyncGeneratorExpression
+features: [object-spread, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorExpression :
+      async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
+        AsyncGeneratorBody }
+
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+var s = Symbol('s');
+
+
+var callCount = 0;
+
+var gen = async function *() {
+  callCount += 1;
+  yield {
+       ...yield yield,
+       ...(function(arg) {
+          var yield = arg;
+          return {...yield};
+       }(yield)),
+       ...yield,
+    }
+};
+
+var iter = gen();
+
+var iter = gen();
+
+iter.next();
+iter.next();
+iter.next({ x: 10, a: 0, b: 0, [s]: 1 });
+iter.next({ y: 20, a: 1, b: 1, [s]: 42 });
+var item = iter.next({ z: 30, b: 2 });
+
+item.then(({ done, value }) => {
+  assert.sameValue(done, false);
+  assert.sameValue(value.x, 10);
+  assert.sameValue(value.y, 20);
+  assert.sameValue(value.z, 30);
+  assert.sameValue(value.a, 1);
+  assert.sameValue(value.b, 2);
+  assert.sameValue(value[s], 42);
+  assert.sameValue(Object.keys(value).length, 5);
+  assert(Object.hasOwnProperty.call(value, s));
+}).then($DONE, $DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/async-generator/yield-identifier-spread-strict.js b/test/language/expressions/async-generator/yield-identifier-spread-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..8c8214d88529e62d097f7171cabf796b82579826
--- /dev/null
+++ b/test/language/expressions/async-generator/yield-identifier-spread-strict.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-identifier-spread-strict.case
+// - src/async-generators/default/async-expression.template
+/*---
+description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Unnamed async generator expression)
+esid: prod-AsyncGeneratorExpression
+features: [object-spread, async-iteration]
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorExpression :
+      async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
+        AsyncGeneratorBody }
+
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+
+var callCount = 0;
+
+var gen = async function *() {
+  callCount += 1;
+  return {
+       ...(function() {
+          var yield;
+          throw new Test262Error();
+       }()),
+    }
+};
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/async-generator/yield-identifier-strict.js b/test/language/expressions/async-generator/yield-identifier-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..1a32a96d3c456feb1b6eb8490f4cb2fe67dcb200
--- /dev/null
+++ b/test/language/expressions/async-generator/yield-identifier-strict.js
@@ -0,0 +1,36 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-identifier-strict.case
+// - src/async-generators/default/async-expression.template
+/*---
+description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Unnamed async generator expression)
+esid: prod-AsyncGeneratorExpression
+features: [async-iteration]
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorExpression :
+      async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
+        AsyncGeneratorBody }
+
+---*/
+
+
+var callCount = 0;
+
+var gen = async function *() {
+  callCount += 1;
+  (function() {
+      var yield;
+      throw new Test262Error();
+    }())
+};
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/async-generator/yield-spread-arr-multiple.js b/test/language/expressions/async-generator/yield-spread-arr-multiple.js
new file mode 100644
index 0000000000000000000000000000000000000000..fff1129dafad9306d000636c71299f814dcf25b2
--- /dev/null
+++ b/test/language/expressions/async-generator/yield-spread-arr-multiple.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-spread-arr-multiple.case
+// - src/async-generators/default/async-expression.template
+/*---
+description: Use yield value in a array spread position (Unnamed async generator expression)
+esid: prod-AsyncGeneratorExpression
+features: [async-iteration]
+flags: [generated, async]
+includes: [compareArray.js]
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorExpression :
+      async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
+        AsyncGeneratorBody }
+
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+
+---*/
+var arr = ['a', 'b', 'c'];
+var item;
+
+
+var callCount = 0;
+
+var gen = async function *() {
+  callCount += 1;
+  yield [...yield yield];
+};
+
+var iter = gen();
+
+iter.next(false);
+item = iter.next(['a', 'b', 'c']);
+
+item.then(({ done, value }) => {
+  item = iter.next(value);
+
+  item.then(({ done, value }) => {
+    assert(compareArray(value, arr));
+    assert.sameValue(done, false);
+  }).then($DONE, $DONE);
+}).catch($DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/async-generator/yield-spread-arr-single.js b/test/language/expressions/async-generator/yield-spread-arr-single.js
new file mode 100644
index 0000000000000000000000000000000000000000..1cce6d8d2072617e2493e38a4bad4cf532f97edb
--- /dev/null
+++ b/test/language/expressions/async-generator/yield-spread-arr-single.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-spread-arr-single.case
+// - src/async-generators/default/async-expression.template
+/*---
+description: Use yield value in a array spread position (Unnamed async generator expression)
+esid: prod-AsyncGeneratorExpression
+features: [async-iteration]
+flags: [generated, async]
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorExpression :
+      async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
+        AsyncGeneratorBody }
+
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+
+---*/
+var arr = ['a', 'b', 'c'];
+
+
+var callCount = 0;
+
+var gen = async function *() {
+  callCount += 1;
+  yield [...yield];
+};
+
+var iter = gen();
+
+iter.next(false);
+var item = iter.next(arr);
+
+item.then(({ done, value }) => {
+  assert.notSameValue(value, arr, 'value is a new array');
+  assert(Array.isArray(value), 'value is an Array exotic object');
+  assert.sameValue(value.length, 3)
+  assert.sameValue(value[0], 'a');
+  assert.sameValue(value[1], 'b');
+  assert.sameValue(value[2], 'c');
+  assert.sameValue(done, false);
+}).then($DONE, $DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/async-generator/yield-spread-obj.js b/test/language/expressions/async-generator/yield-spread-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..717158f88dde38639d1af4cb8e2c201ef0e505af
--- /dev/null
+++ b/test/language/expressions/async-generator/yield-spread-obj.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-spread-obj.case
+// - src/async-generators/default/async-expression.template
+/*---
+description: Use yield value in a object spread position (Unnamed async generator expression)
+esid: prod-AsyncGeneratorExpression
+features: [object-spread, async-iteration]
+flags: [generated, async]
+includes: [compareArray.js]
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorExpression :
+      async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
+        AsyncGeneratorBody }
+
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+
+var callCount = 0;
+
+var gen = async function *() {
+  callCount += 1;
+  yield {
+      ...yield,
+      y: 1,
+      ...yield yield,
+    };
+};
+
+var iter = gen();
+
+iter.next();
+iter.next({ x: 42 });
+iter.next({ x: 'lol' });
+var item = iter.next({ y: 39 });
+
+item.then(({ done, value }) => {
+  assert.sameValue(value.x, 42);
+  assert.sameValue(value.y, 39);
+  assert.sameValue(Object.keys(value).length, 2);
+  assert.sameValue(done, false);
+}).then($DONE, $DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/call/spread-obj-symbol-property.js b/test/language/expressions/call/spread-obj-symbol-property.js
index 9a26e67f60535b3b54c180045e8d5d857021eaa4..456ccb8207a2515fdb9fa5575f2286903decacfb 100644
--- a/test/language/expressions/call/spread-obj-symbol-property.js
+++ b/test/language/expressions/call/spread-obj-symbol-property.js
@@ -39,6 +39,7 @@ var callCount = 0;
 
 (function(obj) {
   assert.sameValue(obj[symbol], 1);
+  assert(Object.hasOwnProperty.call(obj, symbol));
   assert.sameValue(obj.c, 4);
   assert.sameValue(obj.d, 5);
   assert.sameValue(Object.keys(obj).length, 2);
diff --git a/test/language/expressions/class/async-gen-method-static-yield-identifier-spread-strict.js b/test/language/expressions/class/async-gen-method-static-yield-identifier-spread-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..9e8226d81f9290eb77a8d6dcf0ce30ab8510ccf2
--- /dev/null
+++ b/test/language/expressions/class/async-gen-method-static-yield-identifier-spread-strict.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-identifier-spread-strict.case
+// - src/async-generators/default/async-class-expr-static-method.template
+/*---
+description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Static async generator method as a ClassExpression element)
+esid: prod-AsyncGeneratorMethod
+features: [object-spread, async-iteration]
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    ClassElement :
+      static MethodDefinition
+
+    MethodDefinition :
+      AsyncGeneratorMethod
+
+    Async Generator Function Definitions
+
+    AsyncGeneratorMethod :
+      async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+
+var callCount = 0;
+
+var C = class { static async *gen() {
+    callCount += 1;
+    return {
+         ...(function() {
+            var yield;
+            throw new Test262Error();
+         }()),
+      }
+}}
+
+var gen = C.gen;
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/class/async-gen-method-static-yield-identifier-strict.js b/test/language/expressions/class/async-gen-method-static-yield-identifier-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..2adf5b764eadcca7a2dd3157272689cabe28fb9b
--- /dev/null
+++ b/test/language/expressions/class/async-gen-method-static-yield-identifier-strict.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-identifier-strict.case
+// - src/async-generators/default/async-class-expr-static-method.template
+/*---
+description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Static async generator method as a ClassExpression element)
+esid: prod-AsyncGeneratorMethod
+features: [async-iteration]
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    ClassElement :
+      static MethodDefinition
+
+    MethodDefinition :
+      AsyncGeneratorMethod
+
+    Async Generator Function Definitions
+
+    AsyncGeneratorMethod :
+      async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+---*/
+
+
+var callCount = 0;
+
+var C = class { static async *gen() {
+    callCount += 1;
+    (function() {
+        var yield;
+        throw new Test262Error();
+      }())
+}}
+
+var gen = C.gen;
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/class/async-gen-method-static-yield-spread-arr-multiple.js b/test/language/expressions/class/async-gen-method-static-yield-spread-arr-multiple.js
new file mode 100644
index 0000000000000000000000000000000000000000..fc3d81a4ead6878d9cfd97561729de366f4f1a8f
--- /dev/null
+++ b/test/language/expressions/class/async-gen-method-static-yield-spread-arr-multiple.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-spread-arr-multiple.case
+// - src/async-generators/default/async-class-expr-static-method.template
+/*---
+description: Use yield value in a array spread position (Static async generator method as a ClassExpression element)
+esid: prod-AsyncGeneratorMethod
+features: [async-iteration]
+flags: [generated, async]
+includes: [compareArray.js]
+info: |
+    ClassElement :
+      static MethodDefinition
+
+    MethodDefinition :
+      AsyncGeneratorMethod
+
+    Async Generator Function Definitions
+
+    AsyncGeneratorMethod :
+      async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+
+---*/
+var arr = ['a', 'b', 'c'];
+var item;
+
+
+var callCount = 0;
+
+var C = class { static async *gen() {
+    callCount += 1;
+    yield [...yield yield];
+}}
+
+var gen = C.gen;
+
+var iter = gen();
+
+iter.next(false);
+item = iter.next(['a', 'b', 'c']);
+
+item.then(({ done, value }) => {
+  item = iter.next(value);
+
+  item.then(({ done, value }) => {
+    assert(compareArray(value, arr));
+    assert.sameValue(done, false);
+  }).then($DONE, $DONE);
+}).catch($DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/class/async-gen-method-static-yield-spread-arr-single.js b/test/language/expressions/class/async-gen-method-static-yield-spread-arr-single.js
new file mode 100644
index 0000000000000000000000000000000000000000..18f8dd125267c90e2c9f64452dd30e2c392c8bba
--- /dev/null
+++ b/test/language/expressions/class/async-gen-method-static-yield-spread-arr-single.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-spread-arr-single.case
+// - src/async-generators/default/async-class-expr-static-method.template
+/*---
+description: Use yield value in a array spread position (Static async generator method as a ClassExpression element)
+esid: prod-AsyncGeneratorMethod
+features: [async-iteration]
+flags: [generated, async]
+info: |
+    ClassElement :
+      static MethodDefinition
+
+    MethodDefinition :
+      AsyncGeneratorMethod
+
+    Async Generator Function Definitions
+
+    AsyncGeneratorMethod :
+      async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+
+---*/
+var arr = ['a', 'b', 'c'];
+
+
+var callCount = 0;
+
+var C = class { static async *gen() {
+    callCount += 1;
+    yield [...yield];
+}}
+
+var gen = C.gen;
+
+var iter = gen();
+
+iter.next(false);
+var item = iter.next(arr);
+
+item.then(({ done, value }) => {
+  assert.notSameValue(value, arr, 'value is a new array');
+  assert(Array.isArray(value), 'value is an Array exotic object');
+  assert.sameValue(value.length, 3)
+  assert.sameValue(value[0], 'a');
+  assert.sameValue(value[1], 'b');
+  assert.sameValue(value[2], 'c');
+  assert.sameValue(done, false);
+}).then($DONE, $DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/class/async-gen-method-static-yield-spread-obj.js b/test/language/expressions/class/async-gen-method-static-yield-spread-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..9fb44181c02f20d6a53fe52c843154b11a011ac4
--- /dev/null
+++ b/test/language/expressions/class/async-gen-method-static-yield-spread-obj.js
@@ -0,0 +1,59 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-spread-obj.case
+// - src/async-generators/default/async-class-expr-static-method.template
+/*---
+description: Use yield value in a object spread position (Static async generator method as a ClassExpression element)
+esid: prod-AsyncGeneratorMethod
+features: [object-spread, async-iteration]
+flags: [generated, async]
+includes: [compareArray.js]
+info: |
+    ClassElement :
+      static MethodDefinition
+
+    MethodDefinition :
+      AsyncGeneratorMethod
+
+    Async Generator Function Definitions
+
+    AsyncGeneratorMethod :
+      async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+
+var callCount = 0;
+
+var C = class { static async *gen() {
+    callCount += 1;
+    yield {
+        ...yield,
+        y: 1,
+        ...yield yield,
+      };
+}}
+
+var gen = C.gen;
+
+var iter = gen();
+
+iter.next();
+iter.next({ x: 42 });
+iter.next({ x: 'lol' });
+var item = iter.next({ y: 39 });
+
+item.then(({ done, value }) => {
+  assert.sameValue(value.x, 42);
+  assert.sameValue(value.y, 39);
+  assert.sameValue(Object.keys(value).length, 2);
+  assert.sameValue(done, false);
+}).then($DONE, $DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/class/async-gen-method-yield-identifier-spread-strict.js b/test/language/expressions/class/async-gen-method-yield-identifier-spread-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..4a163c721553424271d464f8414f0bc608ac8394
--- /dev/null
+++ b/test/language/expressions/class/async-gen-method-yield-identifier-spread-strict.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-identifier-spread-strict.case
+// - src/async-generators/default/async-class-expr-method.template
+/*---
+description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Async generator method as a ClassExpression element)
+esid: prod-AsyncGeneratorMethod
+features: [object-spread, async-iteration]
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    ClassElement :
+      MethodDefinition
+
+    MethodDefinition :
+      AsyncGeneratorMethod
+
+    Async Generator Function Definitions
+
+    AsyncGeneratorMethod :
+      async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+
+var callCount = 0;
+
+var C = class { async *gen() {
+    callCount += 1;
+    return {
+         ...(function() {
+            var yield;
+            throw new Test262Error();
+         }()),
+      }
+}}
+
+var gen = C.prototype.gen;
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/class/async-gen-method-yield-identifier-strict.js b/test/language/expressions/class/async-gen-method-yield-identifier-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..45fecde820953972f2abadabc36d5133ca8a8a94
--- /dev/null
+++ b/test/language/expressions/class/async-gen-method-yield-identifier-strict.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-identifier-strict.case
+// - src/async-generators/default/async-class-expr-method.template
+/*---
+description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Async generator method as a ClassExpression element)
+esid: prod-AsyncGeneratorMethod
+features: [async-iteration]
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    ClassElement :
+      MethodDefinition
+
+    MethodDefinition :
+      AsyncGeneratorMethod
+
+    Async Generator Function Definitions
+
+    AsyncGeneratorMethod :
+      async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+---*/
+
+
+var callCount = 0;
+
+var C = class { async *gen() {
+    callCount += 1;
+    (function() {
+        var yield;
+        throw new Test262Error();
+      }())
+}}
+
+var gen = C.prototype.gen;
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/class/async-gen-method-yield-spread-arr-multiple.js b/test/language/expressions/class/async-gen-method-yield-spread-arr-multiple.js
new file mode 100644
index 0000000000000000000000000000000000000000..a05af122002938edd2cd58dc32e668182ad92bac
--- /dev/null
+++ b/test/language/expressions/class/async-gen-method-yield-spread-arr-multiple.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-spread-arr-multiple.case
+// - src/async-generators/default/async-class-expr-method.template
+/*---
+description: Use yield value in a array spread position (Async generator method as a ClassExpression element)
+esid: prod-AsyncGeneratorMethod
+features: [async-iteration]
+flags: [generated, async]
+includes: [compareArray.js]
+info: |
+    ClassElement :
+      MethodDefinition
+
+    MethodDefinition :
+      AsyncGeneratorMethod
+
+    Async Generator Function Definitions
+
+    AsyncGeneratorMethod :
+      async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+
+---*/
+var arr = ['a', 'b', 'c'];
+var item;
+
+
+var callCount = 0;
+
+var C = class { async *gen() {
+    callCount += 1;
+    yield [...yield yield];
+}}
+
+var gen = C.prototype.gen;
+
+var iter = gen();
+
+iter.next(false);
+item = iter.next(['a', 'b', 'c']);
+
+item.then(({ done, value }) => {
+  item = iter.next(value);
+
+  item.then(({ done, value }) => {
+    assert(compareArray(value, arr));
+    assert.sameValue(done, false);
+  }).then($DONE, $DONE);
+}).catch($DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/class/async-gen-method-yield-spread-arr-single.js b/test/language/expressions/class/async-gen-method-yield-spread-arr-single.js
new file mode 100644
index 0000000000000000000000000000000000000000..0e9a722b51e6c11f642e54ac9a8b45181eec8bfd
--- /dev/null
+++ b/test/language/expressions/class/async-gen-method-yield-spread-arr-single.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-spread-arr-single.case
+// - src/async-generators/default/async-class-expr-method.template
+/*---
+description: Use yield value in a array spread position (Async generator method as a ClassExpression element)
+esid: prod-AsyncGeneratorMethod
+features: [async-iteration]
+flags: [generated, async]
+info: |
+    ClassElement :
+      MethodDefinition
+
+    MethodDefinition :
+      AsyncGeneratorMethod
+
+    Async Generator Function Definitions
+
+    AsyncGeneratorMethod :
+      async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+
+---*/
+var arr = ['a', 'b', 'c'];
+
+
+var callCount = 0;
+
+var C = class { async *gen() {
+    callCount += 1;
+    yield [...yield];
+}}
+
+var gen = C.prototype.gen;
+
+var iter = gen();
+
+iter.next(false);
+var item = iter.next(arr);
+
+item.then(({ done, value }) => {
+  assert.notSameValue(value, arr, 'value is a new array');
+  assert(Array.isArray(value), 'value is an Array exotic object');
+  assert.sameValue(value.length, 3)
+  assert.sameValue(value[0], 'a');
+  assert.sameValue(value[1], 'b');
+  assert.sameValue(value[2], 'c');
+  assert.sameValue(done, false);
+}).then($DONE, $DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/class/async-gen-method-yield-spread-obj.js b/test/language/expressions/class/async-gen-method-yield-spread-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..08d3385f8b60c701732e7aed3caf15c0ca4f2cae
--- /dev/null
+++ b/test/language/expressions/class/async-gen-method-yield-spread-obj.js
@@ -0,0 +1,59 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-spread-obj.case
+// - src/async-generators/default/async-class-expr-method.template
+/*---
+description: Use yield value in a object spread position (Async generator method as a ClassExpression element)
+esid: prod-AsyncGeneratorMethod
+features: [object-spread, async-iteration]
+flags: [generated, async]
+includes: [compareArray.js]
+info: |
+    ClassElement :
+      MethodDefinition
+
+    MethodDefinition :
+      AsyncGeneratorMethod
+
+    Async Generator Function Definitions
+
+    AsyncGeneratorMethod :
+      async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+
+var callCount = 0;
+
+var C = class { async *gen() {
+    callCount += 1;
+    yield {
+        ...yield,
+        y: 1,
+        ...yield yield,
+      };
+}}
+
+var gen = C.prototype.gen;
+
+var iter = gen();
+
+iter.next();
+iter.next({ x: 42 });
+iter.next({ x: 'lol' });
+var item = iter.next({ y: 39 });
+
+item.then(({ done, value }) => {
+  assert.sameValue(value.x, 42);
+  assert.sameValue(value.y, 39);
+  assert.sameValue(Object.keys(value).length, 2);
+  assert.sameValue(done, false);
+}).then($DONE, $DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/class/gen-method-static-yield-identifier-spread-strict.js b/test/language/expressions/class/gen-method-static-yield-identifier-spread-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..045a8d88179de5fc17119e271d2ce041543e02b4
--- /dev/null
+++ b/test/language/expressions/class/gen-method-static-yield-identifier-spread-strict.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-identifier-spread-strict.case
+// - src/generators/default/class-expr-static-method.template
+/*---
+description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Static generator method as a ClassExpression element)
+esid: prod-GeneratorMethod
+features: [object-spread]
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    ClassElement :
+      static MethodDefinition
+
+    MethodDefinition :
+      GeneratorMethod
+
+    14.4 Generator Function Definitions
+
+    GeneratorMethod :
+      * PropertyName ( UniqueFormalParameters ) { GeneratorBody }
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+var callCount = 0;
+
+var C = class { static *gen() {
+    callCount += 1;
+    return {
+         ...(function() {
+            var yield;
+            throw new Test262Error();
+         }()),
+      }
+}}
+
+var gen = C.gen;
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/class/gen-method-static-yield-identifier-strict.js b/test/language/expressions/class/gen-method-static-yield-identifier-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..7de5baf3dc695005848c1c3c624101843e83219a
--- /dev/null
+++ b/test/language/expressions/class/gen-method-static-yield-identifier-strict.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-identifier-strict.case
+// - src/generators/default/class-expr-static-method.template
+/*---
+description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Static generator method as a ClassExpression element)
+esid: prod-GeneratorMethod
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    ClassElement :
+      static MethodDefinition
+
+    MethodDefinition :
+      GeneratorMethod
+
+    14.4 Generator Function Definitions
+
+    GeneratorMethod :
+      * PropertyName ( UniqueFormalParameters ) { GeneratorBody }
+---*/
+
+var callCount = 0;
+
+var C = class { static *gen() {
+    callCount += 1;
+    (function() {
+        var yield;
+        throw new Test262Error();
+      }())
+}}
+
+var gen = C.gen;
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/class/gen-method-static-yield-spread-arr-multiple.js b/test/language/expressions/class/gen-method-static-yield-spread-arr-multiple.js
new file mode 100644
index 0000000000000000000000000000000000000000..c522fe8c9f2e3ac4a1538945355f41177c07a81c
--- /dev/null
+++ b/test/language/expressions/class/gen-method-static-yield-spread-arr-multiple.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-spread-arr-multiple.case
+// - src/generators/default/class-expr-static-method.template
+/*---
+description: Use yield value in a array spread position (Static generator method as a ClassExpression element)
+esid: prod-GeneratorMethod
+flags: [generated]
+includes: [compareArray.js]
+info: |
+    ClassElement :
+      static MethodDefinition
+
+    MethodDefinition :
+      GeneratorMethod
+
+    14.4 Generator Function Definitions
+
+    GeneratorMethod :
+      * PropertyName ( UniqueFormalParameters ) { GeneratorBody }
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+
+---*/
+var arr = ['a', 'b', 'c'];
+var item;
+
+var callCount = 0;
+
+var C = class { static *gen() {
+    callCount += 1;
+    yield [...yield yield];
+}}
+
+var gen = C.gen;
+
+var iter = gen();
+
+iter.next(false);
+item = iter.next(['a', 'b', 'c']);
+item = iter.next(item.value);
+
+assert(compareArray(item.value, arr));
+assert.sameValue(item.done, false);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/class/gen-method-static-yield-spread-arr-single.js b/test/language/expressions/class/gen-method-static-yield-spread-arr-single.js
new file mode 100644
index 0000000000000000000000000000000000000000..d26fc19a4c0a415a3197960d8dd8ab278e0d975b
--- /dev/null
+++ b/test/language/expressions/class/gen-method-static-yield-spread-arr-single.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-spread-arr-single.case
+// - src/generators/default/class-expr-static-method.template
+/*---
+description: Use yield value in a array spread position (Static generator method as a ClassExpression element)
+esid: prod-GeneratorMethod
+flags: [generated]
+info: |
+    ClassElement :
+      static MethodDefinition
+
+    MethodDefinition :
+      GeneratorMethod
+
+    14.4 Generator Function Definitions
+
+    GeneratorMethod :
+      * PropertyName ( UniqueFormalParameters ) { GeneratorBody }
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+---*/
+var arr = ['a', 'b', 'c'];
+
+var callCount = 0;
+
+var C = class { static *gen() {
+    callCount += 1;
+    yield [...yield];
+}}
+
+var gen = C.gen;
+
+var iter = gen();
+
+iter.next(false);
+var item = iter.next(arr);
+var value = item.value;
+
+assert.notSameValue(value, arr, 'value is a new array');
+assert(Array.isArray(value), 'value is an Array exotic object');
+assert.sameValue(value.length, 3)
+assert.sameValue(value[0], 'a');
+assert.sameValue(value[1], 'b');
+assert.sameValue(value[2], 'c');
+assert.sameValue(item.done, false);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/class/gen-method-static-yield-spread-obj.js b/test/language/expressions/class/gen-method-static-yield-spread-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..22c26e197063cbdad6ee771c8bd74244b6951f69
--- /dev/null
+++ b/test/language/expressions/class/gen-method-static-yield-spread-obj.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-spread-obj.case
+// - src/generators/default/class-expr-static-method.template
+/*---
+description: Use yield value in a object spread position (Static generator method as a ClassExpression element)
+esid: prod-GeneratorMethod
+features: [object-spread]
+flags: [generated]
+includes: [compareArray.js]
+info: |
+    ClassElement :
+      static MethodDefinition
+
+    MethodDefinition :
+      GeneratorMethod
+
+    14.4 Generator Function Definitions
+
+    GeneratorMethod :
+      * PropertyName ( UniqueFormalParameters ) { GeneratorBody }
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+var callCount = 0;
+
+var C = class { static *gen() {
+    callCount += 1;
+    yield {
+        ...yield,
+        y: 1,
+        ...yield yield,
+      };
+}}
+
+var gen = C.gen;
+
+var iter = gen();
+
+iter.next();
+iter.next({ x: 42 });
+iter.next({ x: 'lol' });
+var item = iter.next({ y: 39 });
+
+assert.sameValue(item.value.x, 42);
+assert.sameValue(item.value.y, 39);
+assert.sameValue(Object.keys(item.value).length, 2);
+assert.sameValue(item.done, false);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/class/gen-method-yield-identifier-spread-strict.js b/test/language/expressions/class/gen-method-yield-identifier-spread-strict.js
index b4b808dad8e4c949c6183601c45d99fbb26b5cf4..c60ac8d463339f395983321865c4948791319b3e 100644
--- a/test/language/expressions/class/gen-method-yield-identifier-spread-strict.js
+++ b/test/language/expressions/class/gen-method-yield-identifier-spread-strict.js
@@ -1,8 +1,8 @@
 // This file was procedurally generated from the following sources:
 // - src/generators/yield-identifier-spread-strict.case
-// - src/generators/default/class-method-definition.template
+// - src/generators/default/class-expr-method.template
 /*---
-description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Generator method as a ClassElement)
+description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Generator method as a ClassExpression element)
 esid: prod-GeneratorMethod
 features: [object-spread]
 flags: [generated, onlyStrict]
@@ -10,16 +10,16 @@ negative:
   phase: early
   type: SyntaxError
 info: |
-    ClassElement[Yield, Await]:
-      MethodDefinition[?Yield, ?Await]
+    ClassElement :
+      MethodDefinition
 
-    MethodDefinition[Yield, Await]:
-      GeneratorMethod[?Yield, ?Await]
+    MethodDefinition :
+      GeneratorMethod
 
     14.4 Generator Function Definitions
 
-    GeneratorMethod[Yield, Await]:
-      * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { GeneratorBody }
+    GeneratorMethod :
+      * PropertyName ( UniqueFormalParameters ) { GeneratorBody }
 
     Spread Properties
 
@@ -31,7 +31,7 @@ info: |
 
 var callCount = 0;
 
-class C { *gen() {
+var C = class {*gen() {
     callCount += 1;
     return {
          ...(function() {
diff --git a/test/language/expressions/class/gen-method-yield-identifier-strict.js b/test/language/expressions/class/gen-method-yield-identifier-strict.js
index e9c76cef22181d31dfff003bf7b3e909c5916845..a9e667e528a6f5d612216f0d7469b45c83a6d1c1 100644
--- a/test/language/expressions/class/gen-method-yield-identifier-strict.js
+++ b/test/language/expressions/class/gen-method-yield-identifier-strict.js
@@ -1,29 +1,29 @@
 // This file was procedurally generated from the following sources:
 // - src/generators/yield-identifier-strict.case
-// - src/generators/default/class-method-definition.template
+// - src/generators/default/class-expr-method.template
 /*---
-description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Generator method as a ClassElement)
+description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Generator method as a ClassExpression element)
 esid: prod-GeneratorMethod
 flags: [generated, onlyStrict]
 negative:
   phase: early
   type: SyntaxError
 info: |
-    ClassElement[Yield, Await]:
-      MethodDefinition[?Yield, ?Await]
+    ClassElement :
+      MethodDefinition
 
-    MethodDefinition[Yield, Await]:
-      GeneratorMethod[?Yield, ?Await]
+    MethodDefinition :
+      GeneratorMethod
 
     14.4 Generator Function Definitions
 
-    GeneratorMethod[Yield, Await]:
-      * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { GeneratorBody }
+    GeneratorMethod :
+      * PropertyName ( UniqueFormalParameters ) { GeneratorBody }
 ---*/
 
 var callCount = 0;
 
-class C { *gen() {
+var C = class {*gen() {
     callCount += 1;
     (function() {
         var yield;
diff --git a/test/language/expressions/class/gen-method-yield-spread-arr-multiple.js b/test/language/expressions/class/gen-method-yield-spread-arr-multiple.js
index 2bb68b422c13ff8201f31d547b22175c98785eec..ac42e5da8e12336e06bca9316914295a58054e13 100644
--- a/test/language/expressions/class/gen-method-yield-spread-arr-multiple.js
+++ b/test/language/expressions/class/gen-method-yield-spread-arr-multiple.js
@@ -1,22 +1,22 @@
 // This file was procedurally generated from the following sources:
 // - src/generators/yield-spread-arr-multiple.case
-// - src/generators/default/class-method-definition.template
+// - src/generators/default/class-expr-method.template
 /*---
-description: Use yield value in a array spread position (Generator method as a ClassElement)
+description: Use yield value in a array spread position (Generator method as a ClassExpression element)
 esid: prod-GeneratorMethod
 flags: [generated]
 includes: [compareArray.js]
 info: |
-    ClassElement[Yield, Await]:
-      MethodDefinition[?Yield, ?Await]
+    ClassElement :
+      MethodDefinition
 
-    MethodDefinition[Yield, Await]:
-      GeneratorMethod[?Yield, ?Await]
+    MethodDefinition :
+      GeneratorMethod
 
     14.4 Generator Function Definitions
 
-    GeneratorMethod[Yield, Await]:
-      * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { GeneratorBody }
+    GeneratorMethod :
+      * PropertyName ( UniqueFormalParameters ) { GeneratorBody }
 
     Array Initializer
 
@@ -29,7 +29,7 @@ var item;
 
 var callCount = 0;
 
-class C { *gen() {
+var C = class {*gen() {
     callCount += 1;
     yield [...yield yield];
 }}
diff --git a/test/language/expressions/class/gen-method-yield-spread-arr-single.js b/test/language/expressions/class/gen-method-yield-spread-arr-single.js
index 6732fcd7bd2fef8611fe4653c756a24d6973da69..b1d9e473bad838955ae6af61a5f5a6e1233cf4ca 100644
--- a/test/language/expressions/class/gen-method-yield-spread-arr-single.js
+++ b/test/language/expressions/class/gen-method-yield-spread-arr-single.js
@@ -1,34 +1,32 @@
 // This file was procedurally generated from the following sources:
 // - src/generators/yield-spread-arr-single.case
-// - src/generators/default/class-method-definition.template
+// - src/generators/default/class-expr-method.template
 /*---
-description: Use yield value in a array spread position (Generator method as a ClassElement)
+description: Use yield value in a array spread position (Generator method as a ClassExpression element)
 esid: prod-GeneratorMethod
 flags: [generated]
-includes: [compareArray.js]
 info: |
-    ClassElement[Yield, Await]:
-      MethodDefinition[?Yield, ?Await]
+    ClassElement :
+      MethodDefinition
 
-    MethodDefinition[Yield, Await]:
-      GeneratorMethod[?Yield, ?Await]
+    MethodDefinition :
+      GeneratorMethod
 
     14.4 Generator Function Definitions
 
-    GeneratorMethod[Yield, Await]:
-      * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { GeneratorBody }
+    GeneratorMethod :
+      * PropertyName ( UniqueFormalParameters ) { GeneratorBody }
 
     Array Initializer
 
     SpreadElement[Yield, Await]:
       ...AssignmentExpression[+In, ?Yield, ?Await]
-
 ---*/
 var arr = ['a', 'b', 'c'];
 
 var callCount = 0;
 
-class C { *gen() {
+var C = class {*gen() {
     callCount += 1;
     yield [...yield];
 }}
@@ -38,9 +36,15 @@ var gen = C.prototype.gen;
 var iter = gen();
 
 iter.next(false);
-var item = iter.next(['a', 'b', 'c']);
-
-assert(compareArray(item.value, arr));
+var item = iter.next(arr);
+var value = item.value;
+
+assert.notSameValue(value, arr, 'value is a new array');
+assert(Array.isArray(value), 'value is an Array exotic object');
+assert.sameValue(value.length, 3)
+assert.sameValue(value[0], 'a');
+assert.sameValue(value[1], 'b');
+assert.sameValue(value[2], 'c');
 assert.sameValue(item.done, false);
 
 assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/class/gen-method-yield-spread-obj.js b/test/language/expressions/class/gen-method-yield-spread-obj.js
index 6795c8451735f1079fce64c59fa11d210d6a5f8f..192c508b2b9d4af125de924faa228502852af51a 100644
--- a/test/language/expressions/class/gen-method-yield-spread-obj.js
+++ b/test/language/expressions/class/gen-method-yield-spread-obj.js
@@ -1,23 +1,23 @@
 // This file was procedurally generated from the following sources:
 // - src/generators/yield-spread-obj.case
-// - src/generators/default/class-method-definition.template
+// - src/generators/default/class-expr-method.template
 /*---
-description: Use yield value in a object spread position (Generator method as a ClassElement)
+description: Use yield value in a object spread position (Generator method as a ClassExpression element)
 esid: prod-GeneratorMethod
 features: [object-spread]
 flags: [generated]
 includes: [compareArray.js]
 info: |
-    ClassElement[Yield, Await]:
-      MethodDefinition[?Yield, ?Await]
+    ClassElement :
+      MethodDefinition
 
-    MethodDefinition[Yield, Await]:
-      GeneratorMethod[?Yield, ?Await]
+    MethodDefinition :
+      GeneratorMethod
 
     14.4 Generator Function Definitions
 
-    GeneratorMethod[Yield, Await]:
-      * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { GeneratorBody }
+    GeneratorMethod :
+      * PropertyName ( UniqueFormalParameters ) { GeneratorBody }
 
     Spread Properties
 
@@ -29,7 +29,7 @@ info: |
 
 var callCount = 0;
 
-class C { *gen() {
+var C = class {*gen() {
     callCount += 1;
     yield {
         ...yield,
diff --git a/test/language/expressions/generators/named-yield-identifier-non-strict.js b/test/language/expressions/generators/named-yield-identifier-non-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..857edb209b7b76359f7174ea6ece87b0e3f7e7f3
--- /dev/null
+++ b/test/language/expressions/generators/named-yield-identifier-non-strict.js
@@ -0,0 +1,37 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-identifier-non-strict.case
+// - src/generators/non-strict/expression-named.template
+/*---
+description: Use of yield as a valid identifier in a function body inside a generator body in non strict mode (Generator named expression - valid for non-strict only cases)
+esid: prod-GeneratorExpression
+flags: [generated, noStrict]
+info: |
+    14.4 Generator Function Definitions
+
+    GeneratorExpression:
+      function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody }
+---*/
+
+var callCount = 0;
+
+var gen = function *g() {
+  callCount += 1;
+  return (function(arg) {
+      var yield = arg + 1;
+      return yield;
+    }(yield))
+};
+
+var iter = gen();
+
+var item = iter.next();
+
+assert.sameValue(item.done, false);
+assert.sameValue(item.value, undefined);
+
+item = iter.next(42);
+
+assert.sameValue(item.done, true);
+assert.sameValue(item.value, 43);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/generators/named-yield-identifier-spread-non-strict.js b/test/language/expressions/generators/named-yield-identifier-spread-non-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..2fa759a558cceac995fea24ed36cc7b1343b942d
--- /dev/null
+++ b/test/language/expressions/generators/named-yield-identifier-spread-non-strict.js
@@ -0,0 +1,60 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-identifier-spread-non-strict.case
+// - src/generators/non-strict/expression-named.template
+/*---
+description: Mixed use of object spread and yield as a valid identifier in a function body inside a generator body in non strict mode (Generator named expression - valid for non-strict only cases)
+esid: prod-GeneratorExpression
+features: [object-spread]
+flags: [generated, noStrict]
+info: |
+    14.4 Generator Function Definitions
+
+    GeneratorExpression:
+      function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody }
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+var s = Symbol('s');
+
+var callCount = 0;
+
+var gen = function *g() {
+  callCount += 1;
+  yield {
+       ...yield yield,
+       ...(function(arg) {
+          var yield = arg;
+          return {...yield};
+       }(yield)),
+       ...yield,
+    }
+};
+
+var iter = gen();
+
+var iter = gen();
+
+iter.next();
+iter.next();
+iter.next({ x: 10, a: 0, b: 0, [s]: 1 });
+iter.next({ y: 20, a: 1, b: 1, [s]: 42 });
+var item = iter.next({ z: 30, b: 2 });
+
+var value = item.value;
+
+assert.sameValue(item.done, false);
+assert.sameValue(value.x, 10);
+assert.sameValue(value.y, 20);
+assert.sameValue(value.z, 30);
+assert.sameValue(value.a, 1);
+assert.sameValue(value.b, 2);
+assert.sameValue(value[s], 42);
+assert(Object.hasOwnProperty.call(value, s));
+assert.sameValue(Object.keys(value).length, 5);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/generators/named-yield-identifier-spread-strict.js b/test/language/expressions/generators/named-yield-identifier-spread-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..f375e7a0f8d667b36e7c19c6c694906157bbf500
--- /dev/null
+++ b/test/language/expressions/generators/named-yield-identifier-spread-strict.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-identifier-spread-strict.case
+// - src/generators/default/expression-named.template
+/*---
+description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Named generator expression)
+esid: prod-GeneratorExpression
+features: [object-spread]
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    14.4 Generator Function Definitions
+
+    GeneratorExpression:
+      function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody }
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+var callCount = 0;
+
+var gen = function *g() {
+  callCount += 1;
+  return {
+       ...(function() {
+          var yield;
+          throw new Test262Error();
+       }()),
+    }
+};
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/generators/named-yield-identifier-strict.js b/test/language/expressions/generators/named-yield-identifier-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..70101210b2778885c416262131ebdee0ea1e1fb3
--- /dev/null
+++ b/test/language/expressions/generators/named-yield-identifier-strict.js
@@ -0,0 +1,32 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-identifier-strict.case
+// - src/generators/default/expression-named.template
+/*---
+description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Named generator expression)
+esid: prod-GeneratorExpression
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    14.4 Generator Function Definitions
+
+    GeneratorExpression:
+      function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody }
+---*/
+
+var callCount = 0;
+
+var gen = function *g() {
+  callCount += 1;
+  (function() {
+      var yield;
+      throw new Test262Error();
+    }())
+};
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/generators/named-yield-spread-arr-multiple.js b/test/language/expressions/generators/named-yield-spread-arr-multiple.js
new file mode 100644
index 0000000000000000000000000000000000000000..616f13cb4bda5a0cab44ccf3142d8b82e9ed4ffe
--- /dev/null
+++ b/test/language/expressions/generators/named-yield-spread-arr-multiple.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-spread-arr-multiple.case
+// - src/generators/default/expression-named.template
+/*---
+description: Use yield value in a array spread position (Named generator expression)
+esid: prod-GeneratorExpression
+flags: [generated]
+includes: [compareArray.js]
+info: |
+    14.4 Generator Function Definitions
+
+    GeneratorExpression:
+      function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody }
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+
+---*/
+var arr = ['a', 'b', 'c'];
+var item;
+
+var callCount = 0;
+
+var gen = function *g() {
+  callCount += 1;
+  yield [...yield yield];
+};
+
+var iter = gen();
+
+iter.next(false);
+item = iter.next(['a', 'b', 'c']);
+item = iter.next(item.value);
+
+assert(compareArray(item.value, arr));
+assert.sameValue(item.done, false);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/generators/named-yield-spread-arr-single.js b/test/language/expressions/generators/named-yield-spread-arr-single.js
new file mode 100644
index 0000000000000000000000000000000000000000..b0bd3194efd1b6228c524c9e0b5190247b7ac2ef
--- /dev/null
+++ b/test/language/expressions/generators/named-yield-spread-arr-single.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-spread-arr-single.case
+// - src/generators/default/expression-named.template
+/*---
+description: Use yield value in a array spread position (Named generator expression)
+esid: prod-GeneratorExpression
+flags: [generated]
+info: |
+    14.4 Generator Function Definitions
+
+    GeneratorExpression:
+      function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody }
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+---*/
+var arr = ['a', 'b', 'c'];
+
+var callCount = 0;
+
+var gen = function *g() {
+  callCount += 1;
+  yield [...yield];
+};
+
+var iter = gen();
+
+iter.next(false);
+var item = iter.next(arr);
+var value = item.value;
+
+assert.notSameValue(value, arr, 'value is a new array');
+assert(Array.isArray(value), 'value is an Array exotic object');
+assert.sameValue(value.length, 3)
+assert.sameValue(value[0], 'a');
+assert.sameValue(value[1], 'b');
+assert.sameValue(value[2], 'c');
+assert.sameValue(item.done, false);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/generators/named-yield-spread-obj.js b/test/language/expressions/generators/named-yield-spread-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..86885614767384db9df3935d25aba759e966f80d
--- /dev/null
+++ b/test/language/expressions/generators/named-yield-spread-obj.js
@@ -0,0 +1,47 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-spread-obj.case
+// - src/generators/default/expression-named.template
+/*---
+description: Use yield value in a object spread position (Named generator expression)
+esid: prod-GeneratorExpression
+features: [object-spread]
+flags: [generated]
+includes: [compareArray.js]
+info: |
+    14.4 Generator Function Definitions
+
+    GeneratorExpression:
+      function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody }
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+var callCount = 0;
+
+var gen = function *g() {
+  callCount += 1;
+  yield {
+      ...yield,
+      y: 1,
+      ...yield yield,
+    };
+};
+
+var iter = gen();
+
+iter.next();
+iter.next({ x: 42 });
+iter.next({ x: 'lol' });
+var item = iter.next({ y: 39 });
+
+assert.sameValue(item.value.x, 42);
+assert.sameValue(item.value.y, 39);
+assert.sameValue(Object.keys(item.value).length, 2);
+assert.sameValue(item.done, false);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/generators/yield-identifier-non-strict.js b/test/language/expressions/generators/yield-identifier-non-strict.js
index 80420e6d08ca8f6d0d47b950b153888067e88bc6..8cbb2e7fc8d94d1a621afc3bfa996728a886b11c 100644
--- a/test/language/expressions/generators/yield-identifier-non-strict.js
+++ b/test/language/expressions/generators/yield-identifier-non-strict.js
@@ -9,7 +9,7 @@ info: |
     14.4 Generator Function Definitions
 
     GeneratorExpression:
-      function * BindingIdentifier[+Yield, ~Await]opt ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+      function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody }
 ---*/
 
 var callCount = 0;
diff --git a/test/language/expressions/generators/yield-identifier-spread-non-strict.js b/test/language/expressions/generators/yield-identifier-spread-non-strict.js
index fd9025f6c921ff86800edb859efb0c08027e6c63..05be96d4e7f7f71a44dd3e0068c870d03f1d1387 100644
--- a/test/language/expressions/generators/yield-identifier-spread-non-strict.js
+++ b/test/language/expressions/generators/yield-identifier-spread-non-strict.js
@@ -10,7 +10,7 @@ info: |
     14.4 Generator Function Definitions
 
     GeneratorExpression:
-      function * BindingIdentifier[+Yield, ~Await]opt ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+      function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody }
 
     Spread Properties
 
@@ -19,6 +19,7 @@ info: |
       ...AssignmentExpression[In, ?Yield]
 
 ---*/
+var s = Symbol('s');
 
 var callCount = 0;
 
@@ -40,16 +41,20 @@ var iter = gen();
 
 iter.next();
 iter.next();
-iter.next({ x: 10, a: 0, b: 0 });
-iter.next({ y: 20, a: 1, b: 1 });
+iter.next({ x: 10, a: 0, b: 0, [s]: 1 });
+iter.next({ y: 20, a: 1, b: 1, [s]: 42 });
 var item = iter.next({ z: 30, b: 2 });
 
+var value = item.value;
+
 assert.sameValue(item.done, false);
-assert.sameValue(item.value.x, 10);
-assert.sameValue(item.value.y, 20);
-assert.sameValue(item.value.z, 30);
-assert.sameValue(item.value.a, 1);
-assert.sameValue(item.value.b, 2);
-assert.sameValue(Object.keys(item.value).length, 5);
+assert.sameValue(value.x, 10);
+assert.sameValue(value.y, 20);
+assert.sameValue(value.z, 30);
+assert.sameValue(value.a, 1);
+assert.sameValue(value.b, 2);
+assert.sameValue(value[s], 42);
+assert(Object.hasOwnProperty.call(value, s));
+assert.sameValue(Object.keys(value).length, 5);
 
 assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/generators/yield-identifier-spread-strict.js b/test/language/expressions/generators/yield-identifier-spread-strict.js
index c485c04500d4e9c77fdcee7b45b4e66924f7674a..3b1d37d61779b5d53d1130a0b63a2130280d33b3 100644
--- a/test/language/expressions/generators/yield-identifier-spread-strict.js
+++ b/test/language/expressions/generators/yield-identifier-spread-strict.js
@@ -2,7 +2,7 @@
 // - src/generators/yield-identifier-spread-strict.case
 // - src/generators/default/expression.template
 /*---
-description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Generator expression)
+description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Unnamed generator expression)
 esid: prod-GeneratorExpression
 features: [object-spread]
 flags: [generated, onlyStrict]
@@ -13,7 +13,7 @@ info: |
     14.4 Generator Function Definitions
 
     GeneratorExpression:
-      function * BindingIdentifier[+Yield, ~Await]opt ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+      function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody }
 
     Spread Properties
 
diff --git a/test/language/expressions/generators/yield-identifier-strict.js b/test/language/expressions/generators/yield-identifier-strict.js
index f6bdb03ede1fbade5c2d4d4513d111c35f42fd65..b6554db8fd336286830f401e066f6aa905fe8808 100644
--- a/test/language/expressions/generators/yield-identifier-strict.js
+++ b/test/language/expressions/generators/yield-identifier-strict.js
@@ -2,7 +2,7 @@
 // - src/generators/yield-identifier-strict.case
 // - src/generators/default/expression.template
 /*---
-description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Generator expression)
+description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Unnamed generator expression)
 esid: prod-GeneratorExpression
 flags: [generated, onlyStrict]
 negative:
@@ -12,7 +12,7 @@ info: |
     14.4 Generator Function Definitions
 
     GeneratorExpression:
-      function * BindingIdentifier[+Yield, ~Await]opt ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+      function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody }
 ---*/
 
 var callCount = 0;
diff --git a/test/language/expressions/generators/yield-spread-arr-multiple.js b/test/language/expressions/generators/yield-spread-arr-multiple.js
index 272a6acb666b34fce59c1469b0ada648e4446e89..f8958a970f47f753d87cad7a9483805d89fd19d5 100644
--- a/test/language/expressions/generators/yield-spread-arr-multiple.js
+++ b/test/language/expressions/generators/yield-spread-arr-multiple.js
@@ -2,7 +2,7 @@
 // - src/generators/yield-spread-arr-multiple.case
 // - src/generators/default/expression.template
 /*---
-description: Use yield value in a array spread position (Generator expression)
+description: Use yield value in a array spread position (Unnamed generator expression)
 esid: prod-GeneratorExpression
 flags: [generated]
 includes: [compareArray.js]
@@ -10,7 +10,7 @@ info: |
     14.4 Generator Function Definitions
 
     GeneratorExpression:
-      function * BindingIdentifier[+Yield, ~Await]opt ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+      function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody }
 
     Array Initializer
 
diff --git a/test/language/expressions/generators/yield-spread-arr-single.js b/test/language/expressions/generators/yield-spread-arr-single.js
index 636ac3e889463152bade7dfca5ad105aa910808a..52bb571f71ba7da09b8129909922460abbbb8c03 100644
--- a/test/language/expressions/generators/yield-spread-arr-single.js
+++ b/test/language/expressions/generators/yield-spread-arr-single.js
@@ -2,21 +2,19 @@
 // - src/generators/yield-spread-arr-single.case
 // - src/generators/default/expression.template
 /*---
-description: Use yield value in a array spread position (Generator expression)
+description: Use yield value in a array spread position (Unnamed generator expression)
 esid: prod-GeneratorExpression
 flags: [generated]
-includes: [compareArray.js]
 info: |
     14.4 Generator Function Definitions
 
     GeneratorExpression:
-      function * BindingIdentifier[+Yield, ~Await]opt ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+      function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody }
 
     Array Initializer
 
     SpreadElement[Yield, Await]:
       ...AssignmentExpression[+In, ?Yield, ?Await]
-
 ---*/
 var arr = ['a', 'b', 'c'];
 
@@ -30,9 +28,15 @@ var gen = function *() {
 var iter = gen();
 
 iter.next(false);
-var item = iter.next(['a', 'b', 'c']);
-
-assert(compareArray(item.value, arr));
+var item = iter.next(arr);
+var value = item.value;
+
+assert.notSameValue(value, arr, 'value is a new array');
+assert(Array.isArray(value), 'value is an Array exotic object');
+assert.sameValue(value.length, 3)
+assert.sameValue(value[0], 'a');
+assert.sameValue(value[1], 'b');
+assert.sameValue(value[2], 'c');
 assert.sameValue(item.done, false);
 
 assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/generators/yield-spread-obj.js b/test/language/expressions/generators/yield-spread-obj.js
index f7c6f2e85e857c026fcf6ad4780166c8b027e3c4..e05908ccac28dd833a604e2121f8681677d6700c 100644
--- a/test/language/expressions/generators/yield-spread-obj.js
+++ b/test/language/expressions/generators/yield-spread-obj.js
@@ -2,7 +2,7 @@
 // - src/generators/yield-spread-obj.case
 // - src/generators/default/expression.template
 /*---
-description: Use yield value in a object spread position (Generator expression)
+description: Use yield value in a object spread position (Unnamed generator expression)
 esid: prod-GeneratorExpression
 features: [object-spread]
 flags: [generated]
@@ -11,7 +11,7 @@ info: |
     14.4 Generator Function Definitions
 
     GeneratorExpression:
-      function * BindingIdentifier[+Yield, ~Await]opt ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+      function * BindingIdentifier opt ( FormalParameters ) { GeneratorBody }
 
     Spread Properties
 
diff --git a/test/language/expressions/new/spread-obj-symbol-property.js b/test/language/expressions/new/spread-obj-symbol-property.js
index 33f58683457f86a7dce3845692d653f46d61aef0..ada48fd50f97d01a1adb495b3d1099fe60d94a46 100644
--- a/test/language/expressions/new/spread-obj-symbol-property.js
+++ b/test/language/expressions/new/spread-obj-symbol-property.js
@@ -38,6 +38,7 @@ var callCount = 0;
 
 new function(obj) {
   assert.sameValue(obj[symbol], 1);
+  assert(Object.hasOwnProperty.call(obj, symbol));
   assert.sameValue(obj.c, 4);
   assert.sameValue(obj.d, 5);
   assert.sameValue(Object.keys(obj).length, 2);
diff --git a/test/language/expressions/object/method-definition/async-gen-yield-identifier-non-strict.js b/test/language/expressions/object/method-definition/async-gen-yield-identifier-non-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..f02a132462717661301ae06f9b3e043a71242570
--- /dev/null
+++ b/test/language/expressions/object/method-definition/async-gen-yield-identifier-non-strict.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-identifier-non-strict.case
+// - src/async-generators/non-strict/async-obj-method.template
+/*---
+description: Use of yield as a valid identifier in a function body inside a generator body in non strict mode (Generator method - valid for non-strict only cases)
+esid: prod-AsyncGeneratorMethod
+features: [async-iteration]
+flags: [generated, noStrict, async]
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorMethod :
+      async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+---*/
+
+
+var callCount = 0;
+
+var gen = {
+  async *method() {
+    callCount += 1;
+    return (function(arg) {
+        var yield = arg + 1;
+        return yield;
+      }(yield))
+  }
+}.method;
+
+var iter = gen();
+
+var item = iter.next();
+
+item.then(({ done, value }) => {
+  assert.sameValue(done, false);
+  assert.sameValue(value, undefined);
+});
+
+item = iter.next(42);
+
+item.then(({ done, value }) => {
+  assert.sameValue(done, true);
+  assert.sameValue(value, 43);
+}).then($DONE, $DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/object/method-definition/async-gen-yield-identifier-spread-non-strict.js b/test/language/expressions/object/method-definition/async-gen-yield-identifier-spread-non-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..eeeecd3ef9bd2e3e7a8e9e3af70328341fe4704e
--- /dev/null
+++ b/test/language/expressions/object/method-definition/async-gen-yield-identifier-spread-non-strict.js
@@ -0,0 +1,64 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-identifier-spread-non-strict.case
+// - src/async-generators/non-strict/async-obj-method.template
+/*---
+description: Mixed use of object spread and yield as a valid identifier in a function body inside a generator body in non strict mode (Generator method - valid for non-strict only cases)
+esid: prod-AsyncGeneratorMethod
+features: [object-spread, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorMethod :
+      async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+var s = Symbol('s');
+
+
+var callCount = 0;
+
+var gen = {
+  async *method() {
+    callCount += 1;
+    yield {
+         ...yield yield,
+         ...(function(arg) {
+            var yield = arg;
+            return {...yield};
+         }(yield)),
+         ...yield,
+      }
+  }
+}.method;
+
+var iter = gen();
+
+var iter = gen();
+
+iter.next();
+iter.next();
+iter.next({ x: 10, a: 0, b: 0, [s]: 1 });
+iter.next({ y: 20, a: 1, b: 1, [s]: 42 });
+var item = iter.next({ z: 30, b: 2 });
+
+item.then(({ done, value }) => {
+  assert.sameValue(done, false);
+  assert.sameValue(value.x, 10);
+  assert.sameValue(value.y, 20);
+  assert.sameValue(value.z, 30);
+  assert.sameValue(value.a, 1);
+  assert.sameValue(value.b, 2);
+  assert.sameValue(value[s], 42);
+  assert.sameValue(Object.keys(value).length, 5);
+  assert(Object.hasOwnProperty.call(value, s));
+}).then($DONE, $DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/object/method-definition/async-gen-yield-identifier-spread-strict.js b/test/language/expressions/object/method-definition/async-gen-yield-identifier-spread-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..4ac20d73e7d7d0689135ba0ac5bc9421353a0fb2
--- /dev/null
+++ b/test/language/expressions/object/method-definition/async-gen-yield-identifier-spread-strict.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-identifier-spread-strict.case
+// - src/async-generators/default/async-obj-method.template
+/*---
+description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Async generator method)
+esid: prod-AsyncGeneratorMethod
+features: [object-spread, async-iteration]
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorMethod :
+      async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+var callCount = 0;
+
+var gen = {
+  async *method() {
+    callCount += 1;
+    return {
+         ...(function() {
+            var yield;
+            throw new Test262Error();
+         }()),
+      }
+  }
+}.method;
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/object/method-definition/async-gen-yield-identifier-strict.js b/test/language/expressions/object/method-definition/async-gen-yield-identifier-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..186de46ca5ee2a51ee08ffd392985fd53bd50e30
--- /dev/null
+++ b/test/language/expressions/object/method-definition/async-gen-yield-identifier-strict.js
@@ -0,0 +1,36 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-identifier-strict.case
+// - src/async-generators/default/async-obj-method.template
+/*---
+description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Async generator method)
+esid: prod-AsyncGeneratorMethod
+features: [async-iteration]
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorMethod :
+      async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+---*/
+
+var callCount = 0;
+
+var gen = {
+  async *method() {
+    callCount += 1;
+    (function() {
+        var yield;
+        throw new Test262Error();
+      }())
+  }
+}.method;
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/object/method-definition/async-gen-yield-spread-arr-multiple.js b/test/language/expressions/object/method-definition/async-gen-yield-spread-arr-multiple.js
new file mode 100644
index 0000000000000000000000000000000000000000..984ce0c113271a0f92a35e8a39792c066b93f371
--- /dev/null
+++ b/test/language/expressions/object/method-definition/async-gen-yield-spread-arr-multiple.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-spread-arr-multiple.case
+// - src/async-generators/default/async-obj-method.template
+/*---
+description: Use yield value in a array spread position (Async generator method)
+esid: prod-AsyncGeneratorMethod
+features: [async-iteration]
+flags: [generated, async]
+includes: [compareArray.js]
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorMethod :
+      async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+
+---*/
+var arr = ['a', 'b', 'c'];
+var item;
+
+var callCount = 0;
+
+var gen = {
+  async *method() {
+    callCount += 1;
+    yield [...yield yield];
+  }
+}.method;
+
+var iter = gen();
+
+iter.next(false);
+item = iter.next(['a', 'b', 'c']);
+
+item.then(({ done, value }) => {
+  item = iter.next(value);
+
+  item.then(({ done, value }) => {
+    assert(compareArray(value, arr));
+    assert.sameValue(done, false);
+  }).then($DONE, $DONE);
+}).catch($DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/object/method-definition/async-gen-yield-spread-arr-single.js b/test/language/expressions/object/method-definition/async-gen-yield-spread-arr-single.js
new file mode 100644
index 0000000000000000000000000000000000000000..937834b86291ce18dac705bdc4ecf7cd81ab4aa3
--- /dev/null
+++ b/test/language/expressions/object/method-definition/async-gen-yield-spread-arr-single.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-spread-arr-single.case
+// - src/async-generators/default/async-obj-method.template
+/*---
+description: Use yield value in a array spread position (Async generator method)
+esid: prod-AsyncGeneratorMethod
+features: [async-iteration]
+flags: [generated, async]
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorMethod :
+      async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+
+---*/
+var arr = ['a', 'b', 'c'];
+
+var callCount = 0;
+
+var gen = {
+  async *method() {
+    callCount += 1;
+    yield [...yield];
+  }
+}.method;
+
+var iter = gen();
+
+iter.next(false);
+var item = iter.next(arr);
+
+item.then(({ done, value }) => {
+  assert.notSameValue(value, arr, 'value is a new array');
+  assert(Array.isArray(value), 'value is an Array exotic object');
+  assert.sameValue(value.length, 3)
+  assert.sameValue(value[0], 'a');
+  assert.sameValue(value[1], 'b');
+  assert.sameValue(value[2], 'c');
+  assert.sameValue(done, false);
+}).then($DONE, $DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/object/method-definition/async-gen-yield-spread-obj.js b/test/language/expressions/object/method-definition/async-gen-yield-spread-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..a8de4d64746bf7f6f6f8c5841845f88490d92dae
--- /dev/null
+++ b/test/language/expressions/object/method-definition/async-gen-yield-spread-obj.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-spread-obj.case
+// - src/async-generators/default/async-obj-method.template
+/*---
+description: Use yield value in a object spread position (Async generator method)
+esid: prod-AsyncGeneratorMethod
+features: [object-spread, async-iteration]
+flags: [generated, async]
+includes: [compareArray.js]
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorMethod :
+      async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+var callCount = 0;
+
+var gen = {
+  async *method() {
+    callCount += 1;
+    yield {
+        ...yield,
+        y: 1,
+        ...yield yield,
+      };
+  }
+}.method;
+
+var iter = gen();
+
+iter.next();
+iter.next({ x: 42 });
+iter.next({ x: 'lol' });
+var item = iter.next({ y: 39 });
+
+item.then(({ done, value }) => {
+  assert.sameValue(value.x, 42);
+  assert.sameValue(value.y, 39);
+  assert.sameValue(Object.keys(value).length, 2);
+  assert.sameValue(done, false);
+}).then($DONE, $DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/object/method-definition/generator-yield-identifier-non-strict.js b/test/language/expressions/object/method-definition/gen-yield-identifier-non-strict.js
similarity index 84%
rename from test/language/expressions/object/method-definition/generator-yield-identifier-non-strict.js
rename to test/language/expressions/object/method-definition/gen-yield-identifier-non-strict.js
index 3790d7b8aac833717443291ba037c8cb58446594..bb23db974688cfd336a760d7f9644989c0079820 100644
--- a/test/language/expressions/object/method-definition/generator-yield-identifier-non-strict.js
+++ b/test/language/expressions/object/method-definition/gen-yield-identifier-non-strict.js
@@ -1,6 +1,6 @@
 // This file was procedurally generated from the following sources:
 // - src/generators/yield-identifier-non-strict.case
-// - src/generators/non-strict/method-definition.template
+// - src/generators/non-strict/obj-method.template
 /*---
 description: Use of yield as a valid identifier in a function body inside a generator body in non strict mode (Generator method - valid for non-strict only cases)
 esid: prod-GeneratorMethod
@@ -9,7 +9,7 @@ info: |
     14.4 Generator Function Definitions
 
     GeneratorMethod[Yield, Await]:
-      * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { GeneratorBody }
+      * PropertyName ( UniqueFormalParameters ) { GeneratorBody }
 ---*/
 
 var callCount = 0;
diff --git a/test/language/expressions/object/method-definition/generator-yield-identifier-spread-non-strict.js b/test/language/expressions/object/method-definition/gen-yield-identifier-spread-non-strict.js
similarity index 66%
rename from test/language/expressions/object/method-definition/generator-yield-identifier-spread-non-strict.js
rename to test/language/expressions/object/method-definition/gen-yield-identifier-spread-non-strict.js
index 6e527d280b2a9ab772e3196ee6ff8c115e74afc5..53802b97268b9ee40d5f924ecbfe32dbdaf0578e 100644
--- a/test/language/expressions/object/method-definition/generator-yield-identifier-spread-non-strict.js
+++ b/test/language/expressions/object/method-definition/gen-yield-identifier-spread-non-strict.js
@@ -1,6 +1,6 @@
 // This file was procedurally generated from the following sources:
 // - src/generators/yield-identifier-spread-non-strict.case
-// - src/generators/non-strict/method-definition.template
+// - src/generators/non-strict/obj-method.template
 /*---
 description: Mixed use of object spread and yield as a valid identifier in a function body inside a generator body in non strict mode (Generator method - valid for non-strict only cases)
 esid: prod-GeneratorMethod
@@ -10,7 +10,7 @@ info: |
     14.4 Generator Function Definitions
 
     GeneratorMethod[Yield, Await]:
-      * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { GeneratorBody }
+      * PropertyName ( UniqueFormalParameters ) { GeneratorBody }
 
     Spread Properties
 
@@ -19,6 +19,7 @@ info: |
       ...AssignmentExpression[In, ?Yield]
 
 ---*/
+var s = Symbol('s');
 
 var callCount = 0;
 
@@ -42,16 +43,20 @@ var iter = gen();
 
 iter.next();
 iter.next();
-iter.next({ x: 10, a: 0, b: 0 });
-iter.next({ y: 20, a: 1, b: 1 });
+iter.next({ x: 10, a: 0, b: 0, [s]: 1 });
+iter.next({ y: 20, a: 1, b: 1, [s]: 42 });
 var item = iter.next({ z: 30, b: 2 });
 
+var value = item.value;
+
 assert.sameValue(item.done, false);
-assert.sameValue(item.value.x, 10);
-assert.sameValue(item.value.y, 20);
-assert.sameValue(item.value.z, 30);
-assert.sameValue(item.value.a, 1);
-assert.sameValue(item.value.b, 2);
-assert.sameValue(Object.keys(item.value).length, 5);
+assert.sameValue(value.x, 10);
+assert.sameValue(value.y, 20);
+assert.sameValue(value.z, 30);
+assert.sameValue(value.a, 1);
+assert.sameValue(value.b, 2);
+assert.sameValue(value[s], 42);
+assert(Object.hasOwnProperty.call(value, s));
+assert.sameValue(Object.keys(value).length, 5);
 
 assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/object/method-definition/generator-yield-identifier-spread-strict.js b/test/language/expressions/object/method-definition/gen-yield-identifier-spread-strict.js
similarity index 94%
rename from test/language/expressions/object/method-definition/generator-yield-identifier-spread-strict.js
rename to test/language/expressions/object/method-definition/gen-yield-identifier-spread-strict.js
index 3d43dc780483c73faf4447834b6ae39891c41f63..801084fe312ea6e331a2a0f4f3b7396106ffb8b4 100644
--- a/test/language/expressions/object/method-definition/generator-yield-identifier-spread-strict.js
+++ b/test/language/expressions/object/method-definition/gen-yield-identifier-spread-strict.js
@@ -1,6 +1,6 @@
 // This file was procedurally generated from the following sources:
 // - src/generators/yield-identifier-spread-strict.case
-// - src/generators/default/method-definition.template
+// - src/generators/default/obj-method.template
 /*---
 description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Generator method)
 esid: prod-GeneratorMethod
diff --git a/test/language/expressions/object/method-definition/generator-yield-identifier-strict.js b/test/language/expressions/object/method-definition/gen-yield-identifier-strict.js
similarity index 93%
rename from test/language/expressions/object/method-definition/generator-yield-identifier-strict.js
rename to test/language/expressions/object/method-definition/gen-yield-identifier-strict.js
index 0f1ad962cfce7ca17de982377d3585e1978ece11..617cad48bb78c682ebd59961eb636cedf99959da 100644
--- a/test/language/expressions/object/method-definition/generator-yield-identifier-strict.js
+++ b/test/language/expressions/object/method-definition/gen-yield-identifier-strict.js
@@ -1,6 +1,6 @@
 // This file was procedurally generated from the following sources:
 // - src/generators/yield-identifier-strict.case
-// - src/generators/default/method-definition.template
+// - src/generators/default/obj-method.template
 /*---
 description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Generator method)
 esid: prod-GeneratorMethod
diff --git a/test/language/expressions/object/method-definition/generator-yield-spread-arr-multiple.js b/test/language/expressions/object/method-definition/gen-yield-spread-arr-multiple.js
similarity index 94%
rename from test/language/expressions/object/method-definition/generator-yield-spread-arr-multiple.js
rename to test/language/expressions/object/method-definition/gen-yield-spread-arr-multiple.js
index f0c2c30ea2240952abcbab805f080be746a035cc..c8ac0b133b7ec552caef0f0227069d56e7fee906 100644
--- a/test/language/expressions/object/method-definition/generator-yield-spread-arr-multiple.js
+++ b/test/language/expressions/object/method-definition/gen-yield-spread-arr-multiple.js
@@ -1,6 +1,6 @@
 // This file was procedurally generated from the following sources:
 // - src/generators/yield-spread-arr-multiple.case
-// - src/generators/default/method-definition.template
+// - src/generators/default/obj-method.template
 /*---
 description: Use yield value in a array spread position (Generator method)
 esid: prod-GeneratorMethod
diff --git a/test/language/expressions/object/method-definition/generator-yield-spread-arr-single.js b/test/language/expressions/object/method-definition/gen-yield-spread-arr-single.js
similarity index 68%
rename from test/language/expressions/object/method-definition/generator-yield-spread-arr-single.js
rename to test/language/expressions/object/method-definition/gen-yield-spread-arr-single.js
index a535807236c17704e4ad37371635ed7b289a9c7f..9fe742e13f9e64df505d01f0c4e59b319c5a6d32 100644
--- a/test/language/expressions/object/method-definition/generator-yield-spread-arr-single.js
+++ b/test/language/expressions/object/method-definition/gen-yield-spread-arr-single.js
@@ -1,11 +1,10 @@
 // This file was procedurally generated from the following sources:
 // - src/generators/yield-spread-arr-single.case
-// - src/generators/default/method-definition.template
+// - src/generators/default/obj-method.template
 /*---
 description: Use yield value in a array spread position (Generator method)
 esid: prod-GeneratorMethod
 flags: [generated]
-includes: [compareArray.js]
 info: |
     14.4 Generator Function Definitions
 
@@ -16,7 +15,6 @@ info: |
 
     SpreadElement[Yield, Await]:
       ...AssignmentExpression[+In, ?Yield, ?Await]
-
 ---*/
 var arr = ['a', 'b', 'c'];
 
@@ -32,9 +30,15 @@ var gen = {
 var iter = gen();
 
 iter.next(false);
-var item = iter.next(['a', 'b', 'c']);
-
-assert(compareArray(item.value, arr));
+var item = iter.next(arr);
+var value = item.value;
+
+assert.notSameValue(value, arr, 'value is a new array');
+assert(Array.isArray(value), 'value is an Array exotic object');
+assert.sameValue(value.length, 3)
+assert.sameValue(value[0], 'a');
+assert.sameValue(value[1], 'b');
+assert.sameValue(value[2], 'c');
 assert.sameValue(item.done, false);
 
 assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/object/method-definition/generator-yield-spread-obj.js b/test/language/expressions/object/method-definition/gen-yield-spread-obj.js
similarity index 95%
rename from test/language/expressions/object/method-definition/generator-yield-spread-obj.js
rename to test/language/expressions/object/method-definition/gen-yield-spread-obj.js
index a135327fa7a7fd415f2feb95962a5209b6e0f1c0..c52740bf46e7403f204c566caadb234424108e15 100644
--- a/test/language/expressions/object/method-definition/generator-yield-spread-obj.js
+++ b/test/language/expressions/object/method-definition/gen-yield-spread-obj.js
@@ -1,6 +1,6 @@
 // This file was procedurally generated from the following sources:
 // - src/generators/yield-spread-obj.case
-// - src/generators/default/method-definition.template
+// - src/generators/default/obj-method.template
 /*---
 description: Use yield value in a object spread position (Generator method)
 esid: prod-GeneratorMethod
diff --git a/test/language/expressions/super/call-spread-obj-symbol-property.js b/test/language/expressions/super/call-spread-obj-symbol-property.js
index dd3498438946c96e305f2cec7b83ff7f3f4d4fec..94ba4324f004dff880ef636848a330ebad6ff647 100644
--- a/test/language/expressions/super/call-spread-obj-symbol-property.js
+++ b/test/language/expressions/super/call-spread-obj-symbol-property.js
@@ -37,6 +37,7 @@ var callCount = 0;
 class Test262ParentClass {
   constructor(obj) {
     assert.sameValue(obj[symbol], 1);
+    assert(Object.hasOwnProperty.call(obj, symbol));
     assert.sameValue(obj.c, 4);
     assert.sameValue(obj.d, 5);
     assert.sameValue(Object.keys(obj).length, 2);
diff --git a/test/language/statements/async-generator/yield-identifier-non-strict.js b/test/language/statements/async-generator/yield-identifier-non-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..2a145e811ce823d70d2634f929124dd153e05143
--- /dev/null
+++ b/test/language/statements/async-generator/yield-identifier-non-strict.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-identifier-non-strict.case
+// - src/async-generators/non-strict/async-declaration.template
+/*---
+description: Use of yield as a valid identifier in a function body inside a generator body in non strict mode (Async generator function declaration - valid for non-strict only cases)
+esid: prod-AsyncGeneratorDeclaration
+features: [async-iteration]
+flags: [generated, noStrict, async]
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorDeclaration:
+      async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
+        AsyncGeneratorBody }
+
+---*/
+
+
+var callCount = 0;
+
+async function *gen() {
+  callCount += 1;
+  return (function(arg) {
+      var yield = arg + 1;
+      return yield;
+    }(yield))
+}
+
+var iter = gen();
+
+var item = iter.next();
+
+item.then(({ done, value }) => {
+  assert.sameValue(done, false);
+  assert.sameValue(value, undefined);
+});
+
+item = iter.next(42);
+
+item.then(({ done, value }) => {
+  assert.sameValue(done, true);
+  assert.sameValue(value, 43);
+}).then($DONE, $DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/async-generator/yield-identifier-spread-non-strict.js b/test/language/statements/async-generator/yield-identifier-spread-non-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..8745b43fbd7e2d187b282d1bf935c1953370f3b5
--- /dev/null
+++ b/test/language/statements/async-generator/yield-identifier-spread-non-strict.js
@@ -0,0 +1,63 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-identifier-spread-non-strict.case
+// - src/async-generators/non-strict/async-declaration.template
+/*---
+description: Mixed use of object spread and yield as a valid identifier in a function body inside a generator body in non strict mode (Async generator function declaration - valid for non-strict only cases)
+esid: prod-AsyncGeneratorDeclaration
+features: [object-spread, async-iteration]
+flags: [generated, noStrict, async]
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorDeclaration:
+      async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
+        AsyncGeneratorBody }
+
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+var s = Symbol('s');
+
+
+var callCount = 0;
+
+async function *gen() {
+  callCount += 1;
+  yield {
+       ...yield yield,
+       ...(function(arg) {
+          var yield = arg;
+          return {...yield};
+       }(yield)),
+       ...yield,
+    }
+}
+
+var iter = gen();
+
+var iter = gen();
+
+iter.next();
+iter.next();
+iter.next({ x: 10, a: 0, b: 0, [s]: 1 });
+iter.next({ y: 20, a: 1, b: 1, [s]: 42 });
+var item = iter.next({ z: 30, b: 2 });
+
+item.then(({ done, value }) => {
+  assert.sameValue(done, false);
+  assert.sameValue(value.x, 10);
+  assert.sameValue(value.y, 20);
+  assert.sameValue(value.z, 30);
+  assert.sameValue(value.a, 1);
+  assert.sameValue(value.b, 2);
+  assert.sameValue(value[s], 42);
+  assert.sameValue(Object.keys(value).length, 5);
+  assert(Object.hasOwnProperty.call(value, s));
+}).then($DONE, $DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/async-generator/yield-identifier-spread-strict.js b/test/language/statements/async-generator/yield-identifier-spread-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..70818aae414ed270f6ac0515b895be807b60cb9f
--- /dev/null
+++ b/test/language/statements/async-generator/yield-identifier-spread-strict.js
@@ -0,0 +1,45 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-identifier-spread-strict.case
+// - src/async-generators/default/async-declaration.template
+/*---
+description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Async generator Function declaration)
+esid: prod-AsyncGeneratorDeclaration
+features: [object-spread, async-iteration]
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorDeclaration:
+      async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
+        AsyncGeneratorBody }
+
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+
+var callCount = 0;
+
+async function *gen() {
+  callCount += 1;
+  return {
+       ...(function() {
+          var yield;
+          throw new Test262Error();
+       }()),
+    }
+}
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/async-generator/yield-identifier-strict.js b/test/language/statements/async-generator/yield-identifier-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..1d037a488b49ad55fab681d47c2618097db527a2
--- /dev/null
+++ b/test/language/statements/async-generator/yield-identifier-strict.js
@@ -0,0 +1,36 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-identifier-strict.case
+// - src/async-generators/default/async-declaration.template
+/*---
+description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Async generator Function declaration)
+esid: prod-AsyncGeneratorDeclaration
+features: [async-iteration]
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorDeclaration:
+      async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
+        AsyncGeneratorBody }
+
+---*/
+
+
+var callCount = 0;
+
+async function *gen() {
+  callCount += 1;
+  (function() {
+      var yield;
+      throw new Test262Error();
+    }())
+}
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/async-generator/yield-spread-arr-multiple.js b/test/language/statements/async-generator/yield-spread-arr-multiple.js
new file mode 100644
index 0000000000000000000000000000000000000000..f8a500feb869ab1cb1cd441bb9715f86201ab762
--- /dev/null
+++ b/test/language/statements/async-generator/yield-spread-arr-multiple.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-spread-arr-multiple.case
+// - src/async-generators/default/async-declaration.template
+/*---
+description: Use yield value in a array spread position (Async generator Function declaration)
+esid: prod-AsyncGeneratorDeclaration
+features: [async-iteration]
+flags: [generated, async]
+includes: [compareArray.js]
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorDeclaration:
+      async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
+        AsyncGeneratorBody }
+
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+
+---*/
+var arr = ['a', 'b', 'c'];
+var item;
+
+
+var callCount = 0;
+
+async function *gen() {
+  callCount += 1;
+  yield [...yield yield];
+}
+
+var iter = gen();
+
+iter.next(false);
+item = iter.next(['a', 'b', 'c']);
+
+item.then(({ done, value }) => {
+  item = iter.next(value);
+
+  item.then(({ done, value }) => {
+    assert(compareArray(value, arr));
+    assert.sameValue(done, false);
+  }).then($DONE, $DONE);
+}).catch($DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/async-generator/yield-spread-arr-single.js b/test/language/statements/async-generator/yield-spread-arr-single.js
new file mode 100644
index 0000000000000000000000000000000000000000..5c0877292143357d3fc1e22bdfc17d5e1e7c2c6b
--- /dev/null
+++ b/test/language/statements/async-generator/yield-spread-arr-single.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-spread-arr-single.case
+// - src/async-generators/default/async-declaration.template
+/*---
+description: Use yield value in a array spread position (Async generator Function declaration)
+esid: prod-AsyncGeneratorDeclaration
+features: [async-iteration]
+flags: [generated, async]
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorDeclaration:
+      async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
+        AsyncGeneratorBody }
+
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+
+---*/
+var arr = ['a', 'b', 'c'];
+
+
+var callCount = 0;
+
+async function *gen() {
+  callCount += 1;
+  yield [...yield];
+}
+
+var iter = gen();
+
+iter.next(false);
+var item = iter.next(arr);
+
+item.then(({ done, value }) => {
+  assert.notSameValue(value, arr, 'value is a new array');
+  assert(Array.isArray(value), 'value is an Array exotic object');
+  assert.sameValue(value.length, 3)
+  assert.sameValue(value[0], 'a');
+  assert.sameValue(value[1], 'b');
+  assert.sameValue(value[2], 'c');
+  assert.sameValue(done, false);
+}).then($DONE, $DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/async-generator/yield-spread-obj.js b/test/language/statements/async-generator/yield-spread-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..956b69d8d965dee7a10ab5418b4a1e7faee366af
--- /dev/null
+++ b/test/language/statements/async-generator/yield-spread-obj.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-spread-obj.case
+// - src/async-generators/default/async-declaration.template
+/*---
+description: Use yield value in a object spread position (Async generator Function declaration)
+esid: prod-AsyncGeneratorDeclaration
+features: [object-spread, async-iteration]
+flags: [generated, async]
+includes: [compareArray.js]
+info: |
+    Async Generator Function Definitions
+
+    AsyncGeneratorDeclaration:
+      async [no LineTerminator here] function * BindingIdentifier ( FormalParameters ) {
+        AsyncGeneratorBody }
+
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+
+var callCount = 0;
+
+async function *gen() {
+  callCount += 1;
+  yield {
+      ...yield,
+      y: 1,
+      ...yield yield,
+    };
+}
+
+var iter = gen();
+
+iter.next();
+iter.next({ x: 42 });
+iter.next({ x: 'lol' });
+var item = iter.next({ y: 39 });
+
+item.then(({ done, value }) => {
+  assert.sameValue(value.x, 42);
+  assert.sameValue(value.y, 39);
+  assert.sameValue(Object.keys(value).length, 2);
+  assert.sameValue(done, false);
+}).then($DONE, $DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/class/async-gen-method-static-yield-identifier-spread-strict.js b/test/language/statements/class/async-gen-method-static-yield-identifier-spread-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..056d16e594aad7c8a9453e41273ead36ac643fec
--- /dev/null
+++ b/test/language/statements/class/async-gen-method-static-yield-identifier-spread-strict.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-identifier-spread-strict.case
+// - src/async-generators/default/async-class-decl-static-method.template
+/*---
+description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Static async generator method as a ClassDeclaration element)
+esid: prod-AsyncGeneratorMethod
+features: [object-spread, async-iteration]
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    ClassElement :
+      static MethodDefinition
+
+    MethodDefinition :
+      AsyncGeneratorMethod
+
+    Async Generator Function Definitions
+
+    AsyncGeneratorMethod :
+      async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+
+var callCount = 0;
+
+class C { static async *gen() {
+    callCount += 1;
+    return {
+         ...(function() {
+            var yield;
+            throw new Test262Error();
+         }()),
+      }
+}}
+
+var gen = C.gen;
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/class/async-gen-method-static-yield-identifier-strict.js b/test/language/statements/class/async-gen-method-static-yield-identifier-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..dc4d2876d0e7f090a5b50e264fc8363b87c51c6f
--- /dev/null
+++ b/test/language/statements/class/async-gen-method-static-yield-identifier-strict.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-identifier-strict.case
+// - src/async-generators/default/async-class-decl-static-method.template
+/*---
+description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Static async generator method as a ClassDeclaration element)
+esid: prod-AsyncGeneratorMethod
+features: [async-iteration]
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    ClassElement :
+      static MethodDefinition
+
+    MethodDefinition :
+      AsyncGeneratorMethod
+
+    Async Generator Function Definitions
+
+    AsyncGeneratorMethod :
+      async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+---*/
+
+
+var callCount = 0;
+
+class C { static async *gen() {
+    callCount += 1;
+    (function() {
+        var yield;
+        throw new Test262Error();
+      }())
+}}
+
+var gen = C.gen;
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/class/async-gen-method-static-yield-spread-arr-multiple.js b/test/language/statements/class/async-gen-method-static-yield-spread-arr-multiple.js
new file mode 100644
index 0000000000000000000000000000000000000000..4226899aff9e293a167548f9e5509ea7a6aa013b
--- /dev/null
+++ b/test/language/statements/class/async-gen-method-static-yield-spread-arr-multiple.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-spread-arr-multiple.case
+// - src/async-generators/default/async-class-decl-static-method.template
+/*---
+description: Use yield value in a array spread position (Static async generator method as a ClassDeclaration element)
+esid: prod-AsyncGeneratorMethod
+features: [async-iteration]
+flags: [generated, async]
+includes: [compareArray.js]
+info: |
+    ClassElement :
+      static MethodDefinition
+
+    MethodDefinition :
+      AsyncGeneratorMethod
+
+    Async Generator Function Definitions
+
+    AsyncGeneratorMethod :
+      async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+
+---*/
+var arr = ['a', 'b', 'c'];
+var item;
+
+
+var callCount = 0;
+
+class C { static async *gen() {
+    callCount += 1;
+    yield [...yield yield];
+}}
+
+var gen = C.gen;
+
+var iter = gen();
+
+iter.next(false);
+item = iter.next(['a', 'b', 'c']);
+
+item.then(({ done, value }) => {
+  item = iter.next(value);
+
+  item.then(({ done, value }) => {
+    assert(compareArray(value, arr));
+    assert.sameValue(done, false);
+  }).then($DONE, $DONE);
+}).catch($DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/class/async-gen-method-static-yield-spread-arr-single.js b/test/language/statements/class/async-gen-method-static-yield-spread-arr-single.js
new file mode 100644
index 0000000000000000000000000000000000000000..4bc3dff5a160da3094597ea887bdec314d191bc9
--- /dev/null
+++ b/test/language/statements/class/async-gen-method-static-yield-spread-arr-single.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-spread-arr-single.case
+// - src/async-generators/default/async-class-decl-static-method.template
+/*---
+description: Use yield value in a array spread position (Static async generator method as a ClassDeclaration element)
+esid: prod-AsyncGeneratorMethod
+features: [async-iteration]
+flags: [generated, async]
+info: |
+    ClassElement :
+      static MethodDefinition
+
+    MethodDefinition :
+      AsyncGeneratorMethod
+
+    Async Generator Function Definitions
+
+    AsyncGeneratorMethod :
+      async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+
+---*/
+var arr = ['a', 'b', 'c'];
+
+
+var callCount = 0;
+
+class C { static async *gen() {
+    callCount += 1;
+    yield [...yield];
+}}
+
+var gen = C.gen;
+
+var iter = gen();
+
+iter.next(false);
+var item = iter.next(arr);
+
+item.then(({ done, value }) => {
+  assert.notSameValue(value, arr, 'value is a new array');
+  assert(Array.isArray(value), 'value is an Array exotic object');
+  assert.sameValue(value.length, 3)
+  assert.sameValue(value[0], 'a');
+  assert.sameValue(value[1], 'b');
+  assert.sameValue(value[2], 'c');
+  assert.sameValue(done, false);
+}).then($DONE, $DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/class/async-gen-method-static-yield-spread-obj.js b/test/language/statements/class/async-gen-method-static-yield-spread-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..90598785dea0f1deba272b31dfdeaef0a71b3353
--- /dev/null
+++ b/test/language/statements/class/async-gen-method-static-yield-spread-obj.js
@@ -0,0 +1,59 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-spread-obj.case
+// - src/async-generators/default/async-class-decl-static-method.template
+/*---
+description: Use yield value in a object spread position (Static async generator method as a ClassDeclaration element)
+esid: prod-AsyncGeneratorMethod
+features: [object-spread, async-iteration]
+flags: [generated, async]
+includes: [compareArray.js]
+info: |
+    ClassElement :
+      static MethodDefinition
+
+    MethodDefinition :
+      AsyncGeneratorMethod
+
+    Async Generator Function Definitions
+
+    AsyncGeneratorMethod :
+      async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+
+var callCount = 0;
+
+class C { static async *gen() {
+    callCount += 1;
+    yield {
+        ...yield,
+        y: 1,
+        ...yield yield,
+      };
+}}
+
+var gen = C.gen;
+
+var iter = gen();
+
+iter.next();
+iter.next({ x: 42 });
+iter.next({ x: 'lol' });
+var item = iter.next({ y: 39 });
+
+item.then(({ done, value }) => {
+  assert.sameValue(value.x, 42);
+  assert.sameValue(value.y, 39);
+  assert.sameValue(Object.keys(value).length, 2);
+  assert.sameValue(done, false);
+}).then($DONE, $DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/class/async-gen-method-yield-identifier-spread-strict.js b/test/language/statements/class/async-gen-method-yield-identifier-spread-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..d7e36d36fe8342904efa0587a60ca145c08488fe
--- /dev/null
+++ b/test/language/statements/class/async-gen-method-yield-identifier-spread-strict.js
@@ -0,0 +1,52 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-identifier-spread-strict.case
+// - src/async-generators/default/async-class-decl-method.template
+/*---
+description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Async Generator method as a ClassDeclaration element)
+esid: prod-AsyncGeneratorMethod
+features: [object-spread, async-iteration]
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    ClassElement :
+      MethodDefinition
+
+    MethodDefinition :
+      AsyncGeneratorMethod
+
+    Async Generator Function Definitions
+
+    AsyncGeneratorMethod :
+      async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+
+var callCount = 0;
+
+class C { async *gen() {
+    callCount += 1;
+    return {
+         ...(function() {
+            var yield;
+            throw new Test262Error();
+         }()),
+      }
+}}
+
+var gen = C.prototype.gen;
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/class/async-gen-method-yield-identifier-strict.js b/test/language/statements/class/async-gen-method-yield-identifier-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..8d5038ac9b5a9d9f13b57311108bac2cedf9e347
--- /dev/null
+++ b/test/language/statements/class/async-gen-method-yield-identifier-strict.js
@@ -0,0 +1,43 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-identifier-strict.case
+// - src/async-generators/default/async-class-decl-method.template
+/*---
+description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Async Generator method as a ClassDeclaration element)
+esid: prod-AsyncGeneratorMethod
+features: [async-iteration]
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    ClassElement :
+      MethodDefinition
+
+    MethodDefinition :
+      AsyncGeneratorMethod
+
+    Async Generator Function Definitions
+
+    AsyncGeneratorMethod :
+      async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+---*/
+
+
+var callCount = 0;
+
+class C { async *gen() {
+    callCount += 1;
+    (function() {
+        var yield;
+        throw new Test262Error();
+      }())
+}}
+
+var gen = C.prototype.gen;
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/class/async-gen-method-yield-spread-arr-multiple.js b/test/language/statements/class/async-gen-method-yield-spread-arr-multiple.js
new file mode 100644
index 0000000000000000000000000000000000000000..2ae6c7bba678ad6e02296df34a0eaa26a8462321
--- /dev/null
+++ b/test/language/statements/class/async-gen-method-yield-spread-arr-multiple.js
@@ -0,0 +1,56 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-spread-arr-multiple.case
+// - src/async-generators/default/async-class-decl-method.template
+/*---
+description: Use yield value in a array spread position (Async Generator method as a ClassDeclaration element)
+esid: prod-AsyncGeneratorMethod
+features: [async-iteration]
+flags: [generated, async]
+includes: [compareArray.js]
+info: |
+    ClassElement :
+      MethodDefinition
+
+    MethodDefinition :
+      AsyncGeneratorMethod
+
+    Async Generator Function Definitions
+
+    AsyncGeneratorMethod :
+      async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+
+---*/
+var arr = ['a', 'b', 'c'];
+var item;
+
+
+var callCount = 0;
+
+class C { async *gen() {
+    callCount += 1;
+    yield [...yield yield];
+}}
+
+var gen = C.prototype.gen;
+
+var iter = gen();
+
+iter.next(false);
+item = iter.next(['a', 'b', 'c']);
+
+item.then(({ done, value }) => {
+  item = iter.next(value);
+
+  item.then(({ done, value }) => {
+    assert(compareArray(value, arr));
+    assert.sameValue(done, false);
+  }).then($DONE, $DONE);
+}).catch($DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/class/async-gen-method-yield-spread-arr-single.js b/test/language/statements/class/async-gen-method-yield-spread-arr-single.js
new file mode 100644
index 0000000000000000000000000000000000000000..8a7329e8bc77686558f87ecd58d6818ff46f6999
--- /dev/null
+++ b/test/language/statements/class/async-gen-method-yield-spread-arr-single.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-spread-arr-single.case
+// - src/async-generators/default/async-class-decl-method.template
+/*---
+description: Use yield value in a array spread position (Async Generator method as a ClassDeclaration element)
+esid: prod-AsyncGeneratorMethod
+features: [async-iteration]
+flags: [generated, async]
+info: |
+    ClassElement :
+      MethodDefinition
+
+    MethodDefinition :
+      AsyncGeneratorMethod
+
+    Async Generator Function Definitions
+
+    AsyncGeneratorMethod :
+      async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+
+---*/
+var arr = ['a', 'b', 'c'];
+
+
+var callCount = 0;
+
+class C { async *gen() {
+    callCount += 1;
+    yield [...yield];
+}}
+
+var gen = C.prototype.gen;
+
+var iter = gen();
+
+iter.next(false);
+var item = iter.next(arr);
+
+item.then(({ done, value }) => {
+  assert.notSameValue(value, arr, 'value is a new array');
+  assert(Array.isArray(value), 'value is an Array exotic object');
+  assert.sameValue(value.length, 3)
+  assert.sameValue(value[0], 'a');
+  assert.sameValue(value[1], 'b');
+  assert.sameValue(value[2], 'c');
+  assert.sameValue(done, false);
+}).then($DONE, $DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/class/async-gen-method-yield-spread-obj.js b/test/language/statements/class/async-gen-method-yield-spread-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..01c03f7737c183343d92ad3e1375f038e36e736f
--- /dev/null
+++ b/test/language/statements/class/async-gen-method-yield-spread-obj.js
@@ -0,0 +1,59 @@
+// This file was procedurally generated from the following sources:
+// - src/async-generators/yield-spread-obj.case
+// - src/async-generators/default/async-class-decl-method.template
+/*---
+description: Use yield value in a object spread position (Async Generator method as a ClassDeclaration element)
+esid: prod-AsyncGeneratorMethod
+features: [object-spread, async-iteration]
+flags: [generated, async]
+includes: [compareArray.js]
+info: |
+    ClassElement :
+      MethodDefinition
+
+    MethodDefinition :
+      AsyncGeneratorMethod
+
+    Async Generator Function Definitions
+
+    AsyncGeneratorMethod :
+      async [no LineTerminator here] * PropertyName ( UniqueFormalParameters ) { AsyncGeneratorBody }
+
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+
+var callCount = 0;
+
+class C { async *gen() {
+    callCount += 1;
+    yield {
+        ...yield,
+        y: 1,
+        ...yield yield,
+      };
+}}
+
+var gen = C.prototype.gen;
+
+var iter = gen();
+
+iter.next();
+iter.next({ x: 42 });
+iter.next({ x: 'lol' });
+var item = iter.next({ y: 39 });
+
+item.then(({ done, value }) => {
+  assert.sameValue(value.x, 42);
+  assert.sameValue(value.y, 39);
+  assert.sameValue(Object.keys(value).length, 2);
+  assert.sameValue(done, false);
+}).then($DONE, $DONE);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/class/gen-method-static-yield-identifier-spread-strict.js b/test/language/statements/class/gen-method-static-yield-identifier-spread-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..1ccd80303971d4a394baf1f74a2fb351ee37462c
--- /dev/null
+++ b/test/language/statements/class/gen-method-static-yield-identifier-spread-strict.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-identifier-spread-strict.case
+// - src/generators/default/class-decl-static-method.template
+/*---
+description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Static generator method as a ClassDeclaration element)
+esid: prod-GeneratorMethod
+features: [object-spread]
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    ClassElement :
+      static MethodDefinition
+
+    MethodDefinition :
+      GeneratorMethod
+
+    14.4 Generator Function Definitions
+
+    GeneratorMethod :
+      * PropertyName ( UniqueFormalParameters ) { GeneratorBody }
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+var callCount = 0;
+
+class C {static *gen() {
+    callCount += 1;
+    return {
+         ...(function() {
+            var yield;
+            throw new Test262Error();
+         }()),
+      }
+}}
+
+var gen = C.gen;
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/class/gen-method-static-yield-identifier-strict.js b/test/language/statements/class/gen-method-static-yield-identifier-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..82ffa649c91ab876ea413f05aa1ac19fbede1ccf
--- /dev/null
+++ b/test/language/statements/class/gen-method-static-yield-identifier-strict.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-identifier-strict.case
+// - src/generators/default/class-decl-static-method.template
+/*---
+description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Static generator method as a ClassDeclaration element)
+esid: prod-GeneratorMethod
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    ClassElement :
+      static MethodDefinition
+
+    MethodDefinition :
+      GeneratorMethod
+
+    14.4 Generator Function Definitions
+
+    GeneratorMethod :
+      * PropertyName ( UniqueFormalParameters ) { GeneratorBody }
+---*/
+
+var callCount = 0;
+
+class C {static *gen() {
+    callCount += 1;
+    (function() {
+        var yield;
+        throw new Test262Error();
+      }())
+}}
+
+var gen = C.gen;
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/class/gen-method-static-yield-spread-arr-multiple.js b/test/language/statements/class/gen-method-static-yield-spread-arr-multiple.js
new file mode 100644
index 0000000000000000000000000000000000000000..9a100d24559b5e9914c292ee0321ec079cfa6184
--- /dev/null
+++ b/test/language/statements/class/gen-method-static-yield-spread-arr-multiple.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-spread-arr-multiple.case
+// - src/generators/default/class-decl-static-method.template
+/*---
+description: Use yield value in a array spread position (Static generator method as a ClassDeclaration element)
+esid: prod-GeneratorMethod
+flags: [generated]
+includes: [compareArray.js]
+info: |
+    ClassElement :
+      static MethodDefinition
+
+    MethodDefinition :
+      GeneratorMethod
+
+    14.4 Generator Function Definitions
+
+    GeneratorMethod :
+      * PropertyName ( UniqueFormalParameters ) { GeneratorBody }
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+
+---*/
+var arr = ['a', 'b', 'c'];
+var item;
+
+var callCount = 0;
+
+class C {static *gen() {
+    callCount += 1;
+    yield [...yield yield];
+}}
+
+var gen = C.gen;
+
+var iter = gen();
+
+iter.next(false);
+item = iter.next(['a', 'b', 'c']);
+item = iter.next(item.value);
+
+assert(compareArray(item.value, arr));
+assert.sameValue(item.done, false);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/class/gen-method-static-yield-spread-arr-single.js b/test/language/statements/class/gen-method-static-yield-spread-arr-single.js
new file mode 100644
index 0000000000000000000000000000000000000000..5a74810166a0da06ec3cb24fbfc7a72f8e799dbd
--- /dev/null
+++ b/test/language/statements/class/gen-method-static-yield-spread-arr-single.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-spread-arr-single.case
+// - src/generators/default/class-decl-static-method.template
+/*---
+description: Use yield value in a array spread position (Static generator method as a ClassDeclaration element)
+esid: prod-GeneratorMethod
+flags: [generated]
+info: |
+    ClassElement :
+      static MethodDefinition
+
+    MethodDefinition :
+      GeneratorMethod
+
+    14.4 Generator Function Definitions
+
+    GeneratorMethod :
+      * PropertyName ( UniqueFormalParameters ) { GeneratorBody }
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+---*/
+var arr = ['a', 'b', 'c'];
+
+var callCount = 0;
+
+class C {static *gen() {
+    callCount += 1;
+    yield [...yield];
+}}
+
+var gen = C.gen;
+
+var iter = gen();
+
+iter.next(false);
+var item = iter.next(arr);
+var value = item.value;
+
+assert.notSameValue(value, arr, 'value is a new array');
+assert(Array.isArray(value), 'value is an Array exotic object');
+assert.sameValue(value.length, 3)
+assert.sameValue(value[0], 'a');
+assert.sameValue(value[1], 'b');
+assert.sameValue(value[2], 'c');
+assert.sameValue(item.done, false);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/class/gen-method-static-yield-spread-obj.js b/test/language/statements/class/gen-method-static-yield-spread-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..04a4f30e67bc2d73d49feeec2c8af15290031ee9
--- /dev/null
+++ b/test/language/statements/class/gen-method-static-yield-spread-obj.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-spread-obj.case
+// - src/generators/default/class-decl-static-method.template
+/*---
+description: Use yield value in a object spread position (Static generator method as a ClassDeclaration element)
+esid: prod-GeneratorMethod
+features: [object-spread]
+flags: [generated]
+includes: [compareArray.js]
+info: |
+    ClassElement :
+      static MethodDefinition
+
+    MethodDefinition :
+      GeneratorMethod
+
+    14.4 Generator Function Definitions
+
+    GeneratorMethod :
+      * PropertyName ( UniqueFormalParameters ) { GeneratorBody }
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+var callCount = 0;
+
+class C {static *gen() {
+    callCount += 1;
+    yield {
+        ...yield,
+        y: 1,
+        ...yield yield,
+      };
+}}
+
+var gen = C.gen;
+
+var iter = gen();
+
+iter.next();
+iter.next({ x: 42 });
+iter.next({ x: 'lol' });
+var item = iter.next({ y: 39 });
+
+assert.sameValue(item.value.x, 42);
+assert.sameValue(item.value.y, 39);
+assert.sameValue(Object.keys(item.value).length, 2);
+assert.sameValue(item.done, false);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/class/gen-method-yield-identifier-spread-strict.js b/test/language/statements/class/gen-method-yield-identifier-spread-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..43a076fcfab9fbd7f438b42b5eab02235f698233
--- /dev/null
+++ b/test/language/statements/class/gen-method-yield-identifier-spread-strict.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-identifier-spread-strict.case
+// - src/generators/default/class-decl-method.template
+/*---
+description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Geenerator method as a ClassDeclaration element)
+esid: prod-GeneratorMethod
+features: [object-spread]
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    ClassElement :
+      MethodDefinition
+
+    MethodDefinition :
+      GeneratorMethod
+
+    14.4 Generator Function Definitions
+
+    GeneratorMethod :
+      * PropertyName ( UniqueFormalParameters ) { GeneratorBody }
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+var callCount = 0;
+
+class C { *gen() {
+    callCount += 1;
+    return {
+         ...(function() {
+            var yield;
+            throw new Test262Error();
+         }()),
+      }
+}}
+
+var gen = C.prototype.gen;
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/class/gen-method-yield-identifier-strict.js b/test/language/statements/class/gen-method-yield-identifier-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..ae27517773b2138344f75ccbcb41a63c5f40a1c9
--- /dev/null
+++ b/test/language/statements/class/gen-method-yield-identifier-strict.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-identifier-strict.case
+// - src/generators/default/class-decl-method.template
+/*---
+description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Geenerator method as a ClassDeclaration element)
+esid: prod-GeneratorMethod
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    ClassElement :
+      MethodDefinition
+
+    MethodDefinition :
+      GeneratorMethod
+
+    14.4 Generator Function Definitions
+
+    GeneratorMethod :
+      * PropertyName ( UniqueFormalParameters ) { GeneratorBody }
+---*/
+
+var callCount = 0;
+
+class C { *gen() {
+    callCount += 1;
+    (function() {
+        var yield;
+        throw new Test262Error();
+      }())
+}}
+
+var gen = C.prototype.gen;
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/class/gen-method-yield-spread-arr-multiple.js b/test/language/statements/class/gen-method-yield-spread-arr-multiple.js
new file mode 100644
index 0000000000000000000000000000000000000000..daf4bbd4a2753a8b85b2de5577364a2a8142611d
--- /dev/null
+++ b/test/language/statements/class/gen-method-yield-spread-arr-multiple.js
@@ -0,0 +1,48 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-spread-arr-multiple.case
+// - src/generators/default/class-decl-method.template
+/*---
+description: Use yield value in a array spread position (Geenerator method as a ClassDeclaration element)
+esid: prod-GeneratorMethod
+flags: [generated]
+includes: [compareArray.js]
+info: |
+    ClassElement :
+      MethodDefinition
+
+    MethodDefinition :
+      GeneratorMethod
+
+    14.4 Generator Function Definitions
+
+    GeneratorMethod :
+      * PropertyName ( UniqueFormalParameters ) { GeneratorBody }
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+
+---*/
+var arr = ['a', 'b', 'c'];
+var item;
+
+var callCount = 0;
+
+class C { *gen() {
+    callCount += 1;
+    yield [...yield yield];
+}}
+
+var gen = C.prototype.gen;
+
+var iter = gen();
+
+iter.next(false);
+item = iter.next(['a', 'b', 'c']);
+item = iter.next(item.value);
+
+assert(compareArray(item.value, arr));
+assert.sameValue(item.done, false);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/class/gen-method-yield-spread-arr-single.js b/test/language/statements/class/gen-method-yield-spread-arr-single.js
new file mode 100644
index 0000000000000000000000000000000000000000..86b634eb173265e27e3749d77737367bdbf8387a
--- /dev/null
+++ b/test/language/statements/class/gen-method-yield-spread-arr-single.js
@@ -0,0 +1,50 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-spread-arr-single.case
+// - src/generators/default/class-decl-method.template
+/*---
+description: Use yield value in a array spread position (Geenerator method as a ClassDeclaration element)
+esid: prod-GeneratorMethod
+flags: [generated]
+info: |
+    ClassElement :
+      MethodDefinition
+
+    MethodDefinition :
+      GeneratorMethod
+
+    14.4 Generator Function Definitions
+
+    GeneratorMethod :
+      * PropertyName ( UniqueFormalParameters ) { GeneratorBody }
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+---*/
+var arr = ['a', 'b', 'c'];
+
+var callCount = 0;
+
+class C { *gen() {
+    callCount += 1;
+    yield [...yield];
+}}
+
+var gen = C.prototype.gen;
+
+var iter = gen();
+
+iter.next(false);
+var item = iter.next(arr);
+var value = item.value;
+
+assert.notSameValue(value, arr, 'value is a new array');
+assert(Array.isArray(value), 'value is an Array exotic object');
+assert.sameValue(value.length, 3)
+assert.sameValue(value[0], 'a');
+assert.sameValue(value[1], 'b');
+assert.sameValue(value[2], 'c');
+assert.sameValue(item.done, false);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/class/gen-method-yield-spread-obj.js b/test/language/statements/class/gen-method-yield-spread-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..693003505c5bd97d07eceb9e6959ad97e0b6287e
--- /dev/null
+++ b/test/language/statements/class/gen-method-yield-spread-obj.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-spread-obj.case
+// - src/generators/default/class-decl-method.template
+/*---
+description: Use yield value in a object spread position (Geenerator method as a ClassDeclaration element)
+esid: prod-GeneratorMethod
+features: [object-spread]
+flags: [generated]
+includes: [compareArray.js]
+info: |
+    ClassElement :
+      MethodDefinition
+
+    MethodDefinition :
+      GeneratorMethod
+
+    14.4 Generator Function Definitions
+
+    GeneratorMethod :
+      * PropertyName ( UniqueFormalParameters ) { GeneratorBody }
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+var callCount = 0;
+
+class C { *gen() {
+    callCount += 1;
+    yield {
+        ...yield,
+        y: 1,
+        ...yield yield,
+      };
+}}
+
+var gen = C.prototype.gen;
+
+var iter = gen();
+
+iter.next();
+iter.next({ x: 42 });
+iter.next({ x: 'lol' });
+var item = iter.next({ y: 39 });
+
+assert.sameValue(item.value.x, 42);
+assert.sameValue(item.value.y, 39);
+assert.sameValue(Object.keys(item.value).length, 2);
+assert.sameValue(item.done, false);
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/generators/yield-identifier-non-strict.js b/test/language/statements/generators/yield-identifier-non-strict.js
index d69c887c7d63560e2f1f3301e76b04544e5188e3..afc45810b97adeef3205810772efc3a65e1d3110 100644
--- a/test/language/statements/generators/yield-identifier-non-strict.js
+++ b/test/language/statements/generators/yield-identifier-non-strict.js
@@ -1,6 +1,6 @@
 // This file was procedurally generated from the following sources:
 // - src/generators/yield-identifier-non-strict.case
-// - src/generators/non-strict/statement.template
+// - src/generators/non-strict/declaration.template
 /*---
 description: Use of yield as a valid identifier in a function body inside a generator body in non strict mode (Generator function declaration - valid for non-strict only cases)
 esid: prod-GeneratorDeclaration
diff --git a/test/language/statements/generators/yield-identifier-spread-non-strict.js b/test/language/statements/generators/yield-identifier-spread-non-strict.js
index 98d33db21afde2cd2860de8151f29f768cc37297..0490ee4ac41ababd38e8d47fb04a199722d6e8c8 100644
--- a/test/language/statements/generators/yield-identifier-spread-non-strict.js
+++ b/test/language/statements/generators/yield-identifier-spread-non-strict.js
@@ -1,6 +1,6 @@
 // This file was procedurally generated from the following sources:
 // - src/generators/yield-identifier-spread-non-strict.case
-// - src/generators/non-strict/statement.template
+// - src/generators/non-strict/declaration.template
 /*---
 description: Mixed use of object spread and yield as a valid identifier in a function body inside a generator body in non strict mode (Generator function declaration - valid for non-strict only cases)
 esid: prod-GeneratorDeclaration
@@ -19,6 +19,7 @@ info: |
       ...AssignmentExpression[In, ?Yield]
 
 ---*/
+var s = Symbol('s');
 
 var callCount = 0;
 
@@ -40,16 +41,20 @@ var iter = gen();
 
 iter.next();
 iter.next();
-iter.next({ x: 10, a: 0, b: 0 });
-iter.next({ y: 20, a: 1, b: 1 });
+iter.next({ x: 10, a: 0, b: 0, [s]: 1 });
+iter.next({ y: 20, a: 1, b: 1, [s]: 42 });
 var item = iter.next({ z: 30, b: 2 });
 
+var value = item.value;
+
 assert.sameValue(item.done, false);
-assert.sameValue(item.value.x, 10);
-assert.sameValue(item.value.y, 20);
-assert.sameValue(item.value.z, 30);
-assert.sameValue(item.value.a, 1);
-assert.sameValue(item.value.b, 2);
-assert.sameValue(Object.keys(item.value).length, 5);
+assert.sameValue(value.x, 10);
+assert.sameValue(value.y, 20);
+assert.sameValue(value.z, 30);
+assert.sameValue(value.a, 1);
+assert.sameValue(value.b, 2);
+assert.sameValue(value[s], 42);
+assert(Object.hasOwnProperty.call(value, s));
+assert.sameValue(Object.keys(value).length, 5);
 
 assert.sameValue(callCount, 1);
diff --git a/test/language/statements/generators/yield-identifier-spread-strict.js b/test/language/statements/generators/yield-identifier-spread-strict.js
index 6faf35d9b67619d7c5601653dcc8a0569fb932a6..f682d958becf74962b10ce925933baae9f55dabd 100644
--- a/test/language/statements/generators/yield-identifier-spread-strict.js
+++ b/test/language/statements/generators/yield-identifier-spread-strict.js
@@ -1,8 +1,8 @@
 // This file was procedurally generated from the following sources:
 // - src/generators/yield-identifier-spread-strict.case
-// - src/generators/default/statement.template
+// - src/generators/default/declaration.template
 /*---
-description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Generator function declaration)
+description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (Generator Function declaration)
 esid: prod-GeneratorDeclaration
 features: [object-spread]
 flags: [generated, onlyStrict]
@@ -12,8 +12,8 @@ negative:
 info: |
     14.4 Generator Function Definitions
 
-    GeneratorDeclaration[Yield, Await, Default]:
-      function * BindingIdentifier[?Yield, ?Await] ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+    GeneratorDeclaration :
+      function * BindingIdentifier ( FormalParameters ) { GeneratorBody }
 
     Spread Properties
 
diff --git a/test/language/statements/generators/yield-identifier-strict.js b/test/language/statements/generators/yield-identifier-strict.js
index 90339c3715bd1fc52036dacf956cdee42272901b..7c9c5debea4c167d1ee327817ae4bc522450b2ff 100644
--- a/test/language/statements/generators/yield-identifier-strict.js
+++ b/test/language/statements/generators/yield-identifier-strict.js
@@ -1,8 +1,8 @@
 // This file was procedurally generated from the following sources:
 // - src/generators/yield-identifier-strict.case
-// - src/generators/default/statement.template
+// - src/generators/default/declaration.template
 /*---
-description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Generator function declaration)
+description: It's an early error if the generator body has another function body with yield as an identifier in strict mode. (Generator Function declaration)
 esid: prod-GeneratorDeclaration
 flags: [generated, onlyStrict]
 negative:
@@ -11,8 +11,8 @@ negative:
 info: |
     14.4 Generator Function Definitions
 
-    GeneratorDeclaration[Yield, Await, Default]:
-      function * BindingIdentifier[?Yield, ?Await] ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+    GeneratorDeclaration :
+      function * BindingIdentifier ( FormalParameters ) { GeneratorBody }
 ---*/
 
 var callCount = 0;
diff --git a/test/language/statements/generators/yield-spread-arr-multiple.js b/test/language/statements/generators/yield-spread-arr-multiple.js
index 515ac675b3fba4a623357109b9375d81e95e1f66..1fdf352d0b4e7fb8b79c05dae383a3b0050f15b2 100644
--- a/test/language/statements/generators/yield-spread-arr-multiple.js
+++ b/test/language/statements/generators/yield-spread-arr-multiple.js
@@ -1,16 +1,16 @@
 // This file was procedurally generated from the following sources:
 // - src/generators/yield-spread-arr-multiple.case
-// - src/generators/default/statement.template
+// - src/generators/default/declaration.template
 /*---
-description: Use yield value in a array spread position (Generator function declaration)
+description: Use yield value in a array spread position (Generator Function declaration)
 esid: prod-GeneratorDeclaration
 flags: [generated]
 includes: [compareArray.js]
 info: |
     14.4 Generator Function Definitions
 
-    GeneratorDeclaration[Yield, Await, Default]:
-      function * BindingIdentifier[?Yield, ?Await] ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+    GeneratorDeclaration :
+      function * BindingIdentifier ( FormalParameters ) { GeneratorBody }
 
     Array Initializer
 
diff --git a/test/language/statements/generators/yield-spread-arr-single.js b/test/language/statements/generators/yield-spread-arr-single.js
index ab30e3785ecd90dff05be295c7de2c8a9d6b97fc..1ef357eec972145a22f24f33e3e7ab4a38b437cc 100644
--- a/test/language/statements/generators/yield-spread-arr-single.js
+++ b/test/language/statements/generators/yield-spread-arr-single.js
@@ -1,22 +1,20 @@
 // This file was procedurally generated from the following sources:
 // - src/generators/yield-spread-arr-single.case
-// - src/generators/default/statement.template
+// - src/generators/default/declaration.template
 /*---
-description: Use yield value in a array spread position (Generator function declaration)
+description: Use yield value in a array spread position (Generator Function declaration)
 esid: prod-GeneratorDeclaration
 flags: [generated]
-includes: [compareArray.js]
 info: |
     14.4 Generator Function Definitions
 
-    GeneratorDeclaration[Yield, Await, Default]:
-      function * BindingIdentifier[?Yield, ?Await] ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+    GeneratorDeclaration :
+      function * BindingIdentifier ( FormalParameters ) { GeneratorBody }
 
     Array Initializer
 
     SpreadElement[Yield, Await]:
       ...AssignmentExpression[+In, ?Yield, ?Await]
-
 ---*/
 var arr = ['a', 'b', 'c'];
 
@@ -30,9 +28,15 @@ function *gen() {
 var iter = gen();
 
 iter.next(false);
-var item = iter.next(['a', 'b', 'c']);
-
-assert(compareArray(item.value, arr));
+var item = iter.next(arr);
+var value = item.value;
+
+assert.notSameValue(value, arr, 'value is a new array');
+assert(Array.isArray(value), 'value is an Array exotic object');
+assert.sameValue(value.length, 3)
+assert.sameValue(value[0], 'a');
+assert.sameValue(value[1], 'b');
+assert.sameValue(value[2], 'c');
 assert.sameValue(item.done, false);
 
 assert.sameValue(callCount, 1);
diff --git a/test/language/statements/generators/yield-spread-obj.js b/test/language/statements/generators/yield-spread-obj.js
index da341009469caaa881c290dfd92ccd1fcddd62b6..d5f22061793a1f5233196315e2a8b50b737a5aa0 100644
--- a/test/language/statements/generators/yield-spread-obj.js
+++ b/test/language/statements/generators/yield-spread-obj.js
@@ -1,8 +1,8 @@
 // This file was procedurally generated from the following sources:
 // - src/generators/yield-spread-obj.case
-// - src/generators/default/statement.template
+// - src/generators/default/declaration.template
 /*---
-description: Use yield value in a object spread position (Generator function declaration)
+description: Use yield value in a object spread position (Generator Function declaration)
 esid: prod-GeneratorDeclaration
 features: [object-spread]
 flags: [generated]
@@ -10,8 +10,8 @@ includes: [compareArray.js]
 info: |
     14.4 Generator Function Definitions
 
-    GeneratorDeclaration[Yield, Await, Default]:
-      function * BindingIdentifier[?Yield, ?Await] ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+    GeneratorDeclaration :
+      function * BindingIdentifier ( FormalParameters ) { GeneratorBody }
 
     Spread Properties