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 0000000000..b4b808dad8 --- /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 0000000000..e9c76cef22 --- /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 0000000000..2bb68b422c --- /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 0000000000..6732fcd7bd --- /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 0000000000..6795c84517 --- /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 0000000000..80420e6d08 --- /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 0000000000..fd9025f6c9 --- /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 0000000000..c485c04500 --- /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 0000000000..f6bdb03ede --- /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 0000000000..272a6acb66 --- /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 0000000000..636ac3e889 --- /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 0000000000..f7c6f2e85e --- /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 0000000000..3790d7b8aa --- /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 0000000000..6e527d280b --- /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 0000000000..3d43dc7804 --- /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 0000000000..0f1ad962cf --- /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 0000000000..f0c2c30ea2 --- /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 0000000000..a535807236 --- /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 0000000000..a135327fa7 --- /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 0000000000..d69c887c7d --- /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 0000000000..98d33db21a --- /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 0000000000..6faf35d9b6 --- /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 0000000000..90339c3715 --- /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 0000000000..515ac675b3 --- /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 0000000000..ab30e3785e --- /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 0000000000..da34100946 --- /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);