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 0000000000..87cd550d46 --- /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 0000000000..00b105ad43 --- /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 0000000000..745a8e9279 --- /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 0000000000..ac7328fff2 --- /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 0000000000..c32db4e674 --- /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 0000000000..e02b6938bb --- /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 0000000000..11e0b0a962 --- /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 0000000000..c9e64d90c6 --- /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 0000000000..7baa44f5ad --- /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 0000000000..0659f18886 --- /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 0000000000..20d3bc841f --- /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 0000000000..b15e9da3cd --- /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 0000000000..ebbcb1add8 --- /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 0000000000..0db9d527df --- /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 0000000000..7c84ac4dae --- /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 0000000000..6c9e49f828 --- /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 0000000000..33f431766b --- /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 0000000000..cc7cb640b6 --- /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 0000000000..f7d14c022a --- /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 0000000000..ad49590307 --- /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 0000000000..dcd8f4e68c --- /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 4515d51ef5..8580bb9391 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 0000000000..dd6e4ef0f7 --- /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 d70481d62f..c9454f6921 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 0000000000..1a2ad892d9 --- /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 ddead781f5..f66994b8b1 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 d075f36830..d909462bc7 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 0000000000..43448e0963 --- /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 1237f25f66..285a84b75b 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 84cee1cfd1..67b6e23377 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 219b749fa4..f4ad4f40b5 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 5f31c2ddf6..e3f6b8d5f1 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 87a9869564..3d3e922aac 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 8a8cedcebe..7965be9715 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 0000000000..f40bbe0e54 --- /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 0000000000..6c7ae2960f --- /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 0000000000..a368ba6c3e --- /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 0000000000..6c2b9d59e8 --- /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 0000000000..56c3a3cdf7 --- /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 0000000000..a7c1e8634a --- /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 0000000000..a673d06bba --- /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 0000000000..347e5fcd0a --- /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 0000000000..90bcbe2ed0 --- /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 0000000000..8c8214d885 --- /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 0000000000..1a32a96d3c --- /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 0000000000..fff1129daf --- /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 0000000000..1cce6d8d20 --- /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 0000000000..717158f88d --- /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 9a26e67f60..456ccb8207 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 0000000000..9e8226d81f --- /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 0000000000..2adf5b764e --- /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 0000000000..fc3d81a4ea --- /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 0000000000..18f8dd1252 --- /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 0000000000..9fb44181c0 --- /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 0000000000..4a163c7215 --- /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 0000000000..45fecde820 --- /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 0000000000..a05af12200 --- /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 0000000000..0e9a722b51 --- /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 0000000000..08d3385f8b --- /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 0000000000..045a8d8817 --- /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 0000000000..7de5baf3dc --- /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 0000000000..c522fe8c9f --- /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 0000000000..d26fc19a4c --- /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 0000000000..22c26e1970 --- /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 b4b808dad8..c60ac8d463 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 e9c76cef22..a9e667e528 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 2bb68b422c..ac42e5da8e 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 6732fcd7bd..b1d9e473ba 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']); +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); 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 6795c84517..192c508b2b 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 0000000000..857edb209b --- /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 0000000000..2fa759a558 --- /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 0000000000..f375e7a0f8 --- /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 0000000000..70101210b2 --- /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 0000000000..616f13cb4b --- /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 0000000000..b0bd3194ef --- /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 0000000000..8688561476 --- /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 80420e6d08..8cbb2e7fc8 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 fd9025f6c9..05be96d4e7 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 c485c04500..3b1d37d617 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 f6bdb03ede..b6554db8fd 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 272a6acb66..f8958a970f 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 636ac3e889..52bb571f71 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']); +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); 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 f7c6f2e85e..e05908ccac 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 33f5868345..ada48fd50f 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 0000000000..f02a132462 --- /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 0000000000..eeeecd3ef9 --- /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 0000000000..4ac20d73e7 --- /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 0000000000..186de46ca5 --- /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 0000000000..984ce0c113 --- /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 0000000000..937834b862 --- /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 0000000000..a8de4d6474 --- /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 3790d7b8aa..bb23db9746 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 6e527d280b..53802b9726 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 3d43dc7804..801084fe31 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 0f1ad962cf..617cad48bb 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 f0c2c30ea2..c8ac0b133b 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 a535807236..9fe742e13f 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']); +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); 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 a135327fa7..c52740bf46 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 dd34984389..94ba4324f0 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 0000000000..2a145e811c --- /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 0000000000..8745b43fbd --- /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 0000000000..70818aae41 --- /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 0000000000..1d037a488b --- /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 0000000000..f8a500feb8 --- /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 0000000000..5c08772921 --- /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 0000000000..956b69d8d9 --- /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 0000000000..056d16e594 --- /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 0000000000..dc4d2876d0 --- /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 0000000000..4226899aff --- /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 0000000000..4bc3dff5a1 --- /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 0000000000..90598785de --- /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 0000000000..d7e36d36fe --- /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 0000000000..8d5038ac9b --- /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 0000000000..2ae6c7bba6 --- /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 0000000000..8a7329e8bc --- /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 0000000000..01c03f7737 --- /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 0000000000..1ccd803039 --- /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 0000000000..82ffa649c9 --- /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 0000000000..9a100d2455 --- /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 0000000000..5a74810166 --- /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 0000000000..04a4f30e67 --- /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 0000000000..43a076fcfa --- /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 0000000000..ae27517773 --- /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 0000000000..daf4bbd4a2 --- /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 0000000000..86b634eb17 --- /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 0000000000..693003505c --- /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 d69c887c7d..afc45810b9 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 98d33db21a..0490ee4ac4 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 6faf35d9b6..f682d958be 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 90339c3715..7c9c5debea 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 515ac675b3..1fdf352d0b 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 ab30e3785e..1ef357eec9 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']); +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); 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 da34100946..d5f2206179 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