diff --git a/src/generators/default/class-method-definition.template b/src/generators/default/class-method-definition.template
new file mode 100644
index 0000000000000000000000000000000000000000..4515d51ef532e258330489ef945eec2743a98ed9
--- /dev/null
+++ b/src/generators/default/class-method-definition.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-
+name: Generator method as a ClassElement
+esid: prod-GeneratorMethod
+info: |
+  ClassElement[Yield, Await]:
+    MethodDefinition[?Yield, ?Await]
+
+  MethodDefinition[Yield, Await]:
+    GeneratorMethod[?Yield, ?Await]
+
+  14.4 Generator Function Definitions
+
+  GeneratorMethod[Yield, Await]:
+    * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { 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/expression.template b/src/generators/default/expression.template
new file mode 100644
index 0000000000000000000000000000000000000000..ddead781f517d013651f518821dec6641003e14e
--- /dev/null
+++ b/src/generators/default/expression.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/
+name: Generator expression
+esid: prod-GeneratorExpression
+info: |
+  14.4 Generator Function Definitions
+
+  GeneratorExpression:
+    function * BindingIdentifier[+Yield, ~Await]opt ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+---*/
+
+var callCount = 0;
+
+var gen = function *() {
+  callCount += 1;
+  /*{ body }*/
+};
+
+var iter = gen();
+
+/*{ assertions }*/
+
+assert.sameValue(callCount, 1);
diff --git a/src/generators/default/method-definition.template b/src/generators/default/method-definition.template
new file mode 100644
index 0000000000000000000000000000000000000000..d075f36830b4e1f0bab40ef2db1b081da0aea120
--- /dev/null
+++ b/src/generators/default/method-definition.template
@@ -0,0 +1,27 @@
+// 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-
+name: Generator method
+esid: prod-GeneratorMethod
+info: |
+  14.4 Generator Function Definitions
+
+  GeneratorMethod[Yield, Await]:
+    * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { GeneratorBody }
+---*/
+
+var callCount = 0;
+
+var gen = {
+  *method() {
+    callCount += 1;
+    /*{ body }*/
+  }
+}.method;
+
+var iter = gen();
+
+/*{ assertions }*/
+
+assert.sameValue(callCount, 1);
diff --git a/src/generators/default/statement.template b/src/generators/default/statement.template
new file mode 100644
index 0000000000000000000000000000000000000000..d70481d62f4c369d558e3fa0a08d04c3562cc363
--- /dev/null
+++ b/src/generators/default/statement.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/statements/generators/
+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 }
+---*/
+
+var callCount = 0;
+
+function *gen() {
+  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
new file mode 100644
index 0000000000000000000000000000000000000000..1237f25f660722248b0ad12fde8cf89efa791144
--- /dev/null
+++ b/src/generators/non-strict/expression.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/
+name: Generator expression - valid for non-strict only cases
+esid: prod-GeneratorExpression
+info: |
+  14.4 Generator Function Definitions
+
+  GeneratorExpression:
+    function * BindingIdentifier[+Yield, ~Await]opt ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+---*/
+
+var callCount = 0;
+
+var gen = function *() {
+  callCount += 1;
+  /*{ body }*/
+};
+
+var iter = gen();
+
+/*{ assertions }*/
+
+assert.sameValue(callCount, 1);
diff --git a/src/generators/non-strict/method-definition.template b/src/generators/non-strict/method-definition.template
new file mode 100644
index 0000000000000000000000000000000000000000..84cee1cfd1d7d968f78c0e2cc8c9274134b6acb6
--- /dev/null
+++ b/src/generators/non-strict/method-definition.template
@@ -0,0 +1,27 @@
+// 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-
+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 }
+---*/
+
+var callCount = 0;
+
+var gen = {
+  *method() {
+    callCount += 1;
+    /*{ body }*/
+  }
+}.method;
+
+var iter = gen();
+
+/*{ assertions }*/
+
+assert.sameValue(callCount, 1);
diff --git a/src/generators/non-strict/statement.template b/src/generators/non-strict/statement.template
new file mode 100644
index 0000000000000000000000000000000000000000..5409b5134a6881b1c242fa8b5f892fdc22fc5127
--- /dev/null
+++ b/src/generators/non-strict/statement.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/statements/generators/
+name: Generator function declaration - valid for non-strict only cases
+esid: prod-GeneratorDeclaration
+info: |
+  14.4 Generator Function Definitions
+
+  GeneratorDeclaration[Yield, Await, Default]:
+    function * BindingIdentifier[?Yield, ?Await] ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+---*/
+
+var callCount = 0;
+
+function *gen() {
+  callCount += 1;
+  /*{ body }*/
+}
+
+var iter = gen();
+
+/*{ assertions }*/
+
+assert.sameValue(callCount, 1);
diff --git a/src/generators/yield-identifier-non-strict.case b/src/generators/yield-identifier-non-strict.case
new file mode 100644
index 0000000000000000000000000000000000000000..c8095df915f690a2b2b85ab86f45fbd14a1bd4f6
--- /dev/null
+++ b/src/generators/yield-identifier-non-strict.case
@@ -0,0 +1,26 @@
+// 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]
+---*/
+
+//- body
+  return (function(arg) {
+    var yield = arg + 1;
+    return yield;
+  }(yield))
+//- assertions
+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);
diff --git a/src/generators/yield-identifier-spread-non-strict.case b/src/generators/yield-identifier-spread-non-strict.case
new file mode 100644
index 0000000000000000000000000000000000000000..219b749fa45b4c3e45e3c5f7fe481ca07a756d41
--- /dev/null
+++ b/src/generators/yield-identifier-spread-non-strict.case
@@ -0,0 +1,43 @@
+// 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]
+---*/
+
+//- 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 });
+iter.next({ y: 20, a: 1, b: 1 });
+var item = iter.next({ z: 30, b: 2 });
+
+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);
diff --git a/src/generators/yield-identifier-spread-strict.case b/src/generators/yield-identifier-spread-strict.case
new file mode 100644
index 0000000000000000000000000000000000000000..7c84ac4dae32a7ef6e8fe5e93de91a3bdfe139e7
--- /dev/null
+++ b/src/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/generators/yield-identifier-strict.case b/src/generators/yield-identifier-strict.case
new file mode 100644
index 0000000000000000000000000000000000000000..6c9e49f8288c97dda0bb6884129787a389928acc
--- /dev/null
+++ b/src/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/generators/yield-spread-arr-multiple.case b/src/generators/yield-spread-arr-multiple.case
new file mode 100644
index 0000000000000000000000000000000000000000..9d38f78979e24699fe2c0fdad2e3b9b5653df785
--- /dev/null
+++ b/src/generators/yield-spread-arr-multiple.case
@@ -0,0 +1,27 @@
+// 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
+---*/
+
+//- setup
+var arr = ['a', 'b', 'c'];
+var item;
+//- body
+  yield [...yield yield];
+//- assertions
+iter.next(false);
+item = iter.next(['a', 'b', 'c']);
+item = iter.next(item.value);
+
+assert(compareArray(item.value, arr));
+assert.sameValue(item.done, false);
diff --git a/src/generators/yield-spread-arr-single.case b/src/generators/yield-spread-arr-single.case
new file mode 100644
index 0000000000000000000000000000000000000000..5f31c2ddf6e285784922de9da9b6829edd7c9083
--- /dev/null
+++ b/src/generators/yield-spread-arr-single.case
@@ -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.
+
+/*---
+desc: Use yield value in a array spread position
+template: default
+info: |
+  Array Initializer
+
+  SpreadElement[Yield, Await]:
+    ...AssignmentExpression[+In, ?Yield, ?Await]
+includes:
+  - compareArray.js
+---*/
+
+//- setup
+var arr = ['a', 'b', 'c'];
+//- body
+  yield [...yield];
+//- assertions
+iter.next(false);
+var item = iter.next(['a', 'b', 'c']);
+
+assert(compareArray(item.value, arr));
+assert.sameValue(item.done, false);
diff --git a/src/generators/yield-spread-obj.case b/src/generators/yield-spread-obj.case
new file mode 100644
index 0000000000000000000000000000000000000000..ccddbcfc22e99de7f7141c58cdf24e9cb39df903
--- /dev/null
+++ b/src/generators/yield-spread-obj.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 object spread position
+template: default
+info: |
+  Spread Properties
+
+  PropertyDefinition[Yield]:
+    (...)
+    ...AssignmentExpression[In, ?Yield]
+features: [object-spread]
+includes:
+  - compareArray.js
+---*/
+
+//- body
+  yield {
+    ...yield,
+    y: 1,
+    ...yield yield,
+  };
+//- assertions
+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);
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
new file mode 100644
index 0000000000000000000000000000000000000000..b4b808dad8e4c949c6183601c45d99fbb26b5cf4
--- /dev/null
+++ b/test/language/expressions/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-method-definition.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)
+esid: prod-GeneratorMethod
+features: [object-spread]
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    ClassElement[Yield, Await]:
+      MethodDefinition[?Yield, ?Await]
+
+    MethodDefinition[Yield, Await]:
+      GeneratorMethod[?Yield, ?Await]
+
+    14.4 Generator Function Definitions
+
+    GeneratorMethod[Yield, Await]:
+      * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { 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/expressions/class/gen-method-yield-identifier-strict.js b/test/language/expressions/class/gen-method-yield-identifier-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..e9c76cef22181d31dfff003bf7b3e909c5916845
--- /dev/null
+++ b/test/language/expressions/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-method-definition.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)
+esid: prod-GeneratorMethod
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    ClassElement[Yield, Await]:
+      MethodDefinition[?Yield, ?Await]
+
+    MethodDefinition[Yield, Await]:
+      GeneratorMethod[?Yield, ?Await]
+
+    14.4 Generator Function Definitions
+
+    GeneratorMethod[Yield, Await]:
+      * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { 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/expressions/class/gen-method-yield-spread-arr-multiple.js b/test/language/expressions/class/gen-method-yield-spread-arr-multiple.js
new file mode 100644
index 0000000000000000000000000000000000000000..2bb68b422c13ff8201f31d547b22175c98785eec
--- /dev/null
+++ b/test/language/expressions/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-method-definition.template
+/*---
+description: Use yield value in a array spread position (Generator method as a ClassElement)
+esid: prod-GeneratorMethod
+flags: [generated]
+includes: [compareArray.js]
+info: |
+    ClassElement[Yield, Await]:
+      MethodDefinition[?Yield, ?Await]
+
+    MethodDefinition[Yield, Await]:
+      GeneratorMethod[?Yield, ?Await]
+
+    14.4 Generator Function Definitions
+
+    GeneratorMethod[Yield, Await]:
+      * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { 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/expressions/class/gen-method-yield-spread-arr-single.js b/test/language/expressions/class/gen-method-yield-spread-arr-single.js
new file mode 100644
index 0000000000000000000000000000000000000000..6732fcd7bd2fef8611fe4653c756a24d6973da69
--- /dev/null
+++ b/test/language/expressions/class/gen-method-yield-spread-arr-single.js
@@ -0,0 +1,46 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-spread-arr-single.case
+// - src/generators/default/class-method-definition.template
+/*---
+description: Use yield value in a array spread position (Generator method as a ClassElement)
+esid: prod-GeneratorMethod
+flags: [generated]
+includes: [compareArray.js]
+info: |
+    ClassElement[Yield, Await]:
+      MethodDefinition[?Yield, ?Await]
+
+    MethodDefinition[Yield, Await]:
+      GeneratorMethod[?Yield, ?Await]
+
+    14.4 Generator Function Definitions
+
+    GeneratorMethod[Yield, Await]:
+      * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { 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(['a', 'b', 'c']);
+
+assert(compareArray(item.value, arr));
+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
new file mode 100644
index 0000000000000000000000000000000000000000..6795c8451735f1079fce64c59fa11d210d6a5f8f
--- /dev/null
+++ b/test/language/expressions/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-method-definition.template
+/*---
+description: Use yield value in a object spread position (Generator method as a ClassElement)
+esid: prod-GeneratorMethod
+features: [object-spread]
+flags: [generated]
+includes: [compareArray.js]
+info: |
+    ClassElement[Yield, Await]:
+      MethodDefinition[?Yield, ?Await]
+
+    MethodDefinition[Yield, Await]:
+      GeneratorMethod[?Yield, ?Await]
+
+    14.4 Generator Function Definitions
+
+    GeneratorMethod[Yield, Await]:
+      * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { 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/expressions/generators/yield-identifier-non-strict.js b/test/language/expressions/generators/yield-identifier-non-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..80420e6d08ca8f6d0d47b950b153888067e88bc6
--- /dev/null
+++ b/test/language/expressions/generators/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.template
+/*---
+description: Use of yield as a valid identifier in a function body inside a generator body in non strict mode (Generator expression - valid for non-strict only cases)
+esid: prod-GeneratorExpression
+flags: [generated, noStrict]
+info: |
+    14.4 Generator Function Definitions
+
+    GeneratorExpression:
+      function * BindingIdentifier[+Yield, ~Await]opt ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+---*/
+
+var callCount = 0;
+
+var gen = function *() {
+  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/yield-identifier-spread-non-strict.js b/test/language/expressions/generators/yield-identifier-spread-non-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..fd9025f6c921ff86800edb859efb0c08027e6c63
--- /dev/null
+++ b/test/language/expressions/generators/yield-identifier-spread-non-strict.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-identifier-spread-non-strict.case
+// - src/generators/non-strict/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 (Generator 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[+Yield, ~Await]opt ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+var callCount = 0;
+
+var gen = 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 });
+iter.next({ y: 20, a: 1, b: 1 });
+var item = iter.next({ z: 30, b: 2 });
+
+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(callCount, 1);
diff --git a/test/language/expressions/generators/yield-identifier-spread-strict.js b/test/language/expressions/generators/yield-identifier-spread-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..c485c04500d4e9c77fdcee7b45b4e66924f7674a
--- /dev/null
+++ b/test/language/expressions/generators/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.template
+/*---
+description: It's an early error if the AssignmentExpression is a function body with yield as an identifier in strict mode. (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[+Yield, ~Await]opt ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+var callCount = 0;
+
+var gen = function *() {
+  callCount += 1;
+  return {
+       ...(function() {
+          var yield;
+          throw new Test262Error();
+       }()),
+    }
+};
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/generators/yield-identifier-strict.js b/test/language/expressions/generators/yield-identifier-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..f6bdb03ede1fbade5c2d4d4513d111c35f42fd65
--- /dev/null
+++ b/test/language/expressions/generators/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.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)
+esid: prod-GeneratorExpression
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    14.4 Generator Function Definitions
+
+    GeneratorExpression:
+      function * BindingIdentifier[+Yield, ~Await]opt ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+---*/
+
+var callCount = 0;
+
+var gen = function *() {
+  callCount += 1;
+  (function() {
+      var yield;
+      throw new Test262Error();
+    }())
+};
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/generators/yield-spread-arr-multiple.js b/test/language/expressions/generators/yield-spread-arr-multiple.js
new file mode 100644
index 0000000000000000000000000000000000000000..272a6acb666b34fce59c1469b0ada648e4446e89
--- /dev/null
+++ b/test/language/expressions/generators/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.template
+/*---
+description: Use yield value in a array spread position (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 }
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+
+---*/
+var arr = ['a', 'b', 'c'];
+var item;
+
+var callCount = 0;
+
+var gen = function *() {
+  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/yield-spread-arr-single.js b/test/language/expressions/generators/yield-spread-arr-single.js
new file mode 100644
index 0000000000000000000000000000000000000000..636ac3e889463152bade7dfca5ad105aa910808a
--- /dev/null
+++ b/test/language/expressions/generators/yield-spread-arr-single.js
@@ -0,0 +1,38 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-spread-arr-single.case
+// - src/generators/default/expression.template
+/*---
+description: Use yield value in a array spread position (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 }
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+
+---*/
+var arr = ['a', 'b', 'c'];
+
+var callCount = 0;
+
+var gen = function *() {
+  callCount += 1;
+  yield [...yield];
+};
+
+var iter = gen();
+
+iter.next(false);
+var item = iter.next(['a', 'b', 'c']);
+
+assert(compareArray(item.value, arr));
+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
new file mode 100644
index 0000000000000000000000000000000000000000..f7c6f2e85e857c026fcf6ad4780166c8b027e3c4
--- /dev/null
+++ b/test/language/expressions/generators/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.template
+/*---
+description: Use yield value in a object spread position (Generator expression)
+esid: prod-GeneratorExpression
+features: [object-spread]
+flags: [generated]
+includes: [compareArray.js]
+info: |
+    14.4 Generator Function Definitions
+
+    GeneratorExpression:
+      function * BindingIdentifier[+Yield, ~Await]opt ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+var callCount = 0;
+
+var gen = 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 });
+
+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/object/method-definition/generator-yield-identifier-non-strict.js b/test/language/expressions/object/method-definition/generator-yield-identifier-non-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..3790d7b8aac833717443291ba037c8cb58446594
--- /dev/null
+++ b/test/language/expressions/object/method-definition/generator-yield-identifier-non-strict.js
@@ -0,0 +1,39 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-identifier-non-strict.case
+// - src/generators/non-strict/method-definition.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
+flags: [generated, noStrict]
+info: |
+    14.4 Generator Function Definitions
+
+    GeneratorMethod[Yield, Await]:
+      * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { GeneratorBody }
+---*/
+
+var callCount = 0;
+
+var gen = {
+  *method() {
+    callCount += 1;
+    return (function(arg) {
+        var yield = arg + 1;
+        return yield;
+      }(yield))
+  }
+}.method;
+
+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/object/method-definition/generator-yield-identifier-spread-non-strict.js b/test/language/expressions/object/method-definition/generator-yield-identifier-spread-non-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..6e527d280b2a9ab772e3196ee6ff8c115e74afc5
--- /dev/null
+++ b/test/language/expressions/object/method-definition/generator-yield-identifier-spread-non-strict.js
@@ -0,0 +1,57 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-identifier-spread-non-strict.case
+// - src/generators/non-strict/method-definition.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
+features: [object-spread]
+flags: [generated, noStrict]
+info: |
+    14.4 Generator Function Definitions
+
+    GeneratorMethod[Yield, Await]:
+      * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { GeneratorBody }
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+var callCount = 0;
+
+var gen = {
+  *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 });
+iter.next({ y: 20, a: 1, b: 1 });
+var item = iter.next({ z: 30, b: 2 });
+
+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(callCount, 1);
diff --git a/test/language/expressions/object/method-definition/generator-yield-identifier-spread-strict.js b/test/language/expressions/object/method-definition/generator-yield-identifier-spread-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..3d43dc780483c73faf4447834b6ae39891c41f63
--- /dev/null
+++ b/test/language/expressions/object/method-definition/generator-yield-identifier-spread-strict.js
@@ -0,0 +1,44 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-identifier-spread-strict.case
+// - src/generators/default/method-definition.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
+features: [object-spread]
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    14.4 Generator Function Definitions
+
+    GeneratorMethod[Yield, Await]:
+      * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { GeneratorBody }
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+var callCount = 0;
+
+var gen = {
+  *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/generator-yield-identifier-strict.js b/test/language/expressions/object/method-definition/generator-yield-identifier-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..0f1ad962cfce7ca17de982377d3585e1978ece11
--- /dev/null
+++ b/test/language/expressions/object/method-definition/generator-yield-identifier-strict.js
@@ -0,0 +1,34 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-identifier-strict.case
+// - src/generators/default/method-definition.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
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    14.4 Generator Function Definitions
+
+    GeneratorMethod[Yield, Await]:
+      * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { GeneratorBody }
+---*/
+
+var callCount = 0;
+
+var gen = {
+  *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/generator-yield-spread-arr-multiple.js b/test/language/expressions/object/method-definition/generator-yield-spread-arr-multiple.js
new file mode 100644
index 0000000000000000000000000000000000000000..f0c2c30ea2240952abcbab805f080be746a035cc
--- /dev/null
+++ b/test/language/expressions/object/method-definition/generator-yield-spread-arr-multiple.js
@@ -0,0 +1,42 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-spread-arr-multiple.case
+// - src/generators/default/method-definition.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
+
+    GeneratorMethod[Yield, Await]:
+      * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { GeneratorBody }
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+
+---*/
+var arr = ['a', 'b', 'c'];
+var item;
+
+var callCount = 0;
+
+var gen = {
+  *method() {
+    callCount += 1;
+    yield [...yield yield];
+  }
+}.method;
+
+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/object/method-definition/generator-yield-spread-arr-single.js b/test/language/expressions/object/method-definition/generator-yield-spread-arr-single.js
new file mode 100644
index 0000000000000000000000000000000000000000..a535807236c17704e4ad37371635ed7b289a9c7f
--- /dev/null
+++ b/test/language/expressions/object/method-definition/generator-yield-spread-arr-single.js
@@ -0,0 +1,40 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-spread-arr-single.case
+// - src/generators/default/method-definition.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
+
+    GeneratorMethod[Yield, Await]:
+      * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { GeneratorBody }
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+
+---*/
+var arr = ['a', 'b', 'c'];
+
+var callCount = 0;
+
+var gen = {
+  *method() {
+    callCount += 1;
+    yield [...yield];
+  }
+}.method;
+
+var iter = gen();
+
+iter.next(false);
+var item = iter.next(['a', 'b', 'c']);
+
+assert(compareArray(item.value, arr));
+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/generator-yield-spread-obj.js
new file mode 100644
index 0000000000000000000000000000000000000000..a135327fa7a7fd415f2feb95962a5209b6e0f1c0
--- /dev/null
+++ b/test/language/expressions/object/method-definition/generator-yield-spread-obj.js
@@ -0,0 +1,49 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-spread-obj.case
+// - src/generators/default/method-definition.template
+/*---
+description: Use yield value in a object spread position (Generator method)
+esid: prod-GeneratorMethod
+features: [object-spread]
+flags: [generated]
+includes: [compareArray.js]
+info: |
+    14.4 Generator Function Definitions
+
+    GeneratorMethod[Yield, Await]:
+      * PropertyName[?Yield, ?Await] ( UniqueFormalParameters[+Yield, ~Await] ) { GeneratorBody }
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+var callCount = 0;
+
+var gen = {
+  *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 });
+
+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
new file mode 100644
index 0000000000000000000000000000000000000000..d69c887c7d63560e2f1f3301e76b04544e5188e3
--- /dev/null
+++ b/test/language/statements/generators/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/statement.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
+flags: [generated, noStrict]
+info: |
+    14.4 Generator Function Definitions
+
+    GeneratorDeclaration[Yield, Await, Default]:
+      function * BindingIdentifier[?Yield, ?Await] ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+---*/
+
+var callCount = 0;
+
+function *gen() {
+  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/statements/generators/yield-identifier-spread-non-strict.js b/test/language/statements/generators/yield-identifier-spread-non-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..98d33db21afde2cd2860de8151f29f768cc37297
--- /dev/null
+++ b/test/language/statements/generators/yield-identifier-spread-non-strict.js
@@ -0,0 +1,55 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-identifier-spread-non-strict.case
+// - src/generators/non-strict/statement.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
+features: [object-spread]
+flags: [generated, noStrict]
+info: |
+    14.4 Generator Function Definitions
+
+    GeneratorDeclaration[Yield, Await, Default]:
+      function * BindingIdentifier[?Yield, ?Await] ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+var callCount = 0;
+
+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 });
+iter.next({ y: 20, a: 1, b: 1 });
+var item = iter.next({ z: 30, b: 2 });
+
+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(callCount, 1);
diff --git a/test/language/statements/generators/yield-identifier-spread-strict.js b/test/language/statements/generators/yield-identifier-spread-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..6faf35d9b67619d7c5601653dcc8a0569fb932a6
--- /dev/null
+++ b/test/language/statements/generators/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/statement.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)
+esid: prod-GeneratorDeclaration
+features: [object-spread]
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    14.4 Generator Function Definitions
+
+    GeneratorDeclaration[Yield, Await, Default]:
+      function * BindingIdentifier[?Yield, ?Await] ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+var callCount = 0;
+
+function *gen() {
+  callCount += 1;
+  return {
+       ...(function() {
+          var yield;
+          throw new Test262Error();
+       }()),
+    }
+}
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/generators/yield-identifier-strict.js b/test/language/statements/generators/yield-identifier-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..90339c3715bd1fc52036dacf956cdee42272901b
--- /dev/null
+++ b/test/language/statements/generators/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/statement.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)
+esid: prod-GeneratorDeclaration
+flags: [generated, onlyStrict]
+negative:
+  phase: early
+  type: SyntaxError
+info: |
+    14.4 Generator Function Definitions
+
+    GeneratorDeclaration[Yield, Await, Default]:
+      function * BindingIdentifier[?Yield, ?Await] ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+---*/
+
+var callCount = 0;
+
+function *gen() {
+  callCount += 1;
+  (function() {
+      var yield;
+      throw new Test262Error();
+    }())
+}
+
+var iter = gen();
+
+
+
+assert.sameValue(callCount, 1);
diff --git a/test/language/statements/generators/yield-spread-arr-multiple.js b/test/language/statements/generators/yield-spread-arr-multiple.js
new file mode 100644
index 0000000000000000000000000000000000000000..515ac675b3fba4a623357109b9375d81e95e1f66
--- /dev/null
+++ b/test/language/statements/generators/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/statement.template
+/*---
+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 }
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+
+---*/
+var arr = ['a', 'b', 'c'];
+var item;
+
+var callCount = 0;
+
+function *gen() {
+  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/statements/generators/yield-spread-arr-single.js b/test/language/statements/generators/yield-spread-arr-single.js
new file mode 100644
index 0000000000000000000000000000000000000000..ab30e3785ecd90dff05be295c7de2c8a9d6b97fc
--- /dev/null
+++ b/test/language/statements/generators/yield-spread-arr-single.js
@@ -0,0 +1,38 @@
+// This file was procedurally generated from the following sources:
+// - src/generators/yield-spread-arr-single.case
+// - src/generators/default/statement.template
+/*---
+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 }
+
+    Array Initializer
+
+    SpreadElement[Yield, Await]:
+      ...AssignmentExpression[+In, ?Yield, ?Await]
+
+---*/
+var arr = ['a', 'b', 'c'];
+
+var callCount = 0;
+
+function *gen() {
+  callCount += 1;
+  yield [...yield];
+}
+
+var iter = gen();
+
+iter.next(false);
+var item = iter.next(['a', 'b', 'c']);
+
+assert(compareArray(item.value, arr));
+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
new file mode 100644
index 0000000000000000000000000000000000000000..da341009469caaa881c290dfd92ccd1fcddd62b6
--- /dev/null
+++ b/test/language/statements/generators/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/statement.template
+/*---
+description: Use yield value in a object spread position (Generator function declaration)
+esid: prod-GeneratorDeclaration
+features: [object-spread]
+flags: [generated]
+includes: [compareArray.js]
+info: |
+    14.4 Generator Function Definitions
+
+    GeneratorDeclaration[Yield, Await, Default]:
+      function * BindingIdentifier[?Yield, ?Await] ( FormalParameters[+Yield, ~Await] ) { GeneratorBody }
+
+    Spread Properties
+
+    PropertyDefinition[Yield]:
+      (...)
+      ...AssignmentExpression[In, ?Yield]
+
+---*/
+
+var callCount = 0;
+
+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 });
+
+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);